{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "ea5577eb-bde6-4871-bb36-22d168ec602c",
   "metadata": {},
   "source": [
    "# 1. Imports and toggle"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "158eaf69-c00c-463c-b38c-b927b7ed50dd",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Cell 1: Imports and configuration\n",
    "\n",
    "from basic_libraries import os, np, plt, xr\n",
    "from ape_funcs import get_full_data_fpaths, surf_temp_giver\n",
    "from A_up_functions import extract_strictly_increasing_segment as esis\n",
    "from descending_MF_funcs import (\n",
    "    build_draft_mask_dict as bdmd,\n",
    "    save_mass_flux_datasets as smfd,\n",
    "    compute_density as cd,\n",
    "    plot_diagnostic_profiles as pdp,\n",
    "    plot_dual_domain_means as pddm,\n",
    "    plot_mnet_singlepanel as pmnsp,\n",
    "    plot_dual_domain_means_pretty as pddmp,\n",
    "    interpolate_profiles_to_grid as iptg,\n",
    "    compute_fractional_change as cfc,\n",
    "    plot_fractional_change_panel as pfcp,\n",
    "    compute_mass_weighted_mean as cmwm,\n",
    "    compute_mass_flux_weighted_mean as cmfwm,\n",
    "    combine_vertical_means_to_df as cvmtdf,\n",
    ")\n",
    "\n",
    "# Toggle mass flux debug mode\n",
    "check_MF = False\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "532925b0-4e55-4421-9260-2a196477f845",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<module 'descending_MF_funcs' from '/Volumes/COO/MFP_NJ/NOTEBOOKS/descending_MF_funcs.py'>"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import importlib\n",
    "import descending_MF_funcs # initial import\n",
    "\n",
    "importlib.reload(descending_MF_funcs)  # reload after editing"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8c27a0fa-bed0-4309-b8f8-fe37ab59ffe6",
   "metadata": {},
   "source": [
    "# 2. Load FV3 Data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "18c178ea-199a-44ef-a5ee-a993e99e5367",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Cell 2: Load 3D FV3 data for each surface temperature case\n",
    "surf_temps = ['280K', '290K', '300K', '310K']\n",
    "\n",
    "root_dir = r'...'\n",
    "fname = '_hourly3d.nc'\n",
    "root_names = ['Ts280', 'Ts290', 'Ts300', 'Ts310']\n",
    "\n",
    "varis = ['qn', 'qp','w', 'prec_mp']  # variables: vertical velocity, cloud condensate, temperature, precip\n",
    "fpaths = [os.path.join(root_dir, Ts + fname) for Ts in root_names]\n",
    "\n",
    "data_dic = {k: xr.open_dataset(fpath, decode_times=False)[varis] \n",
    "            for k,fpath in zip(surf_temps,fpaths)}\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "# Set destination directory for MF dataset outputs\n",
    "mf_save_dir = os.path.join(\n",
    "    '...'\n",
    ")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c85ae44f-93db-40da-8f0f-45019b186c2d",
   "metadata": {},
   "source": [
    "# 3. Load and prepare 1D data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "6e480dab-e4f6-48e8-82ce-1a916e270dd0",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Cell 3: Load and time-average 1D height and temperature profiles\n",
    "oneDfpaths = r'...'\n",
    "pparte, sparte = 'Ts', '_prod_1d_mean.nc'\n",
    "\n",
    "fpaths_1d = [\n",
    "    os.path.join(oneDfpaths, pparte + Ts[:3] + sparte)\n",
    "    for Ts in surf_temps\n",
    "]\n",
    "\n",
    "height_var, temp_var, humidity = 'zfull', 'tabs', 'qv'\n",
    "\n",
    "\n",
    "oneD_dictionary = {\n",
    "    k: xr.open_dataset(fpath, decode_times=False)[[height_var, temp_var,humidity]]\n",
    "    for k, fpath in zip(surf_temps, fpaths_1d)\n",
    "}\n",
    "\n",
    "# Compute mean vertical profiles\n",
    "temp_1d_dict = {\n",
    "    k: oneD_dictionary[k][temp_var].mean(dim='time') for k in oneD_dictionary\n",
    "}\n",
    "zfull_1d_dict = {\n",
    "    k: oneD_dictionary[k][height_var].mean(dim='time') for k in oneD_dictionary\n",
    "}\n",
    "\n",
    "humidity_1d_dict = {\n",
    "    k: oneD_dictionary[k][humidity].mean(dim='time') for k in oneD_dictionary\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0a782aa6-d7b1-41a7-bc1f-9ddd03073d07",
   "metadata": {},
   "source": [
    "# 4. Assign vertical coordinate info"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "d40563a8-cc6d-4e13-a314-6914420f4b24",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Cell 4: Assign vertical coordinate info (zfull and temp_profile) to 3D datasets\n",
    "\n",
    "# Identify strictly increasing temperature regions (tropopause)\n",
    "temp_vert_coords = {\n",
    "    k: esis(temp_1d_dict[k].values) for k in temp_1d_dict\n",
    "}\n",
    "\n",
    "# Assign vertical coordinates to each dataset\n",
    "ds_exp_vert = {\n",
    "    k: data_dic[k].assign_coords(\n",
    "        zfull=(\"pfull\", zfull_1d_dict[k].values),\n",
    "        temp_profile=(\"pfull\", temp_1d_dict[k].values),\n",
    "    )\n",
    "    for k in data_dic\n",
    "}\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a66f90b1-bb3d-4b08-801d-bef0fd166857",
   "metadata": {},
   "source": [
    "# 5. Trim data to tropopause levels"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "837950f5-071d-4c86-8eb4-566c43a66b4c",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Cell 5: Select data only in strictly increasing temperature region (above tropopause)\n",
    "\n",
    "trop_ds_dic = {\n",
    "    k: ds_exp_vert[k].isel(pfull=slice(int(np.argmax(temp_vert_coords[k][1])), None))\n",
    "    for k in ds_exp_vert\n",
    "}\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "103f3e80-7fc9-4343-b587-2cc792720ec9",
   "metadata": {},
   "outputs": [],
   "source": [
    "dic_tabs = {\n",
    "    k: temp_1d_dict[k].assign_coords(\n",
    "        zfull=(\"pfull\", zfull_1d_dict[k].values),\n",
    "        temp_profile=(\"pfull\", temp_1d_dict[k].values),\n",
    "    )\n",
    "    for k in data_dic\n",
    "}\n",
    "\n",
    "trop_temps = {\n",
    "    k: dic_tabs[k].isel(pfull=slice(int(np.argmax(temp_vert_coords[k][1])), None))\n",
    "    for k in dic_tabs\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "2ccece42-9741-45de-90d6-30b9cae4daf7",
   "metadata": {},
   "outputs": [],
   "source": [
    "dic_humidity = {\n",
    "    k: humidity_1d_dict[k].assign_coords(\n",
    "        zfull=(\"pfull\", zfull_1d_dict[k].values),\n",
    "        temp_profile=(\"pfull\", temp_1d_dict[k].values),\n",
    "    )\n",
    "    for k in data_dic\n",
    "}\n",
    "\n",
    "trop_humidity = {\n",
    "    k: dic_humidity[k].isel(pfull=slice(int(np.argmax(temp_vert_coords[k][1])), None))\n",
    "    for k in dic_tabs\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "bf83e2e4-bab5-4082-85ca-41afd8a7a7d1",
   "metadata": {},
   "source": [
    "# 6. Build updraft masks"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "8bf25999-646d-453a-8f3b-893f7424cf68",
   "metadata": {},
   "outputs": [],
   "source": [
    "from tqdm import tqdm\n",
    "\n",
    "def build_draft_mask_condensate_free_dict(trop_ds_dic, w_umbrales, downdrafts=False):\n",
    "    \"\"\"\n",
    "    Generate binary masks indicating regions with either draft or negative draft activity.\n",
    "\n",
    "    Parameters:\n",
    "    - trop_ds_dic: dict[str, xarray.DataArray]\n",
    "        Dictionary of xarray dataArray keyed by surface temperature strings (e.g., '280K')\n",
    "    - w_umbrales: list[tuple[float, float]]\n",
    "        List of (lower, upper) threshold tuples for vertical velocity (w) for each Ts case\n",
    "\n",
    "    Returns:\n",
    "    - dict[str, xarray.DataArray]\n",
    "        Dictionary of binary masks (1 if either updraft or downdraft condition is met) keyed by Ts case\n",
    "    \"\"\"\n",
    "    Ts_names = sorted(list(trop_ds_dic.keys()))\n",
    "    \n",
    "    # Extract lower and upper w thresholds for each case\n",
    "    w_thresholds = {k: val for k, val in zip(trop_ds_dic.keys(), w_umbrales)}\n",
    "\n",
    "    # Initialize dictionary to hold the combined mask for each Ts case\n",
    "    mask_holder_combined = {}\n",
    "\n",
    "    # Loop through each dataset and corresponding Ts name\n",
    "    for Ts_name, (k, dataset) in tqdm(zip(Ts_names, trop_ds_dic.items()),\n",
    "                                      total=len(Ts_names), desc=\"Processing dataArrays\"):\n",
    "\n",
    "        # Extract variable arrays from dataset\n",
    "        w = dataset['w'].values    # Vertical velocity\n",
    "\n",
    "        # Define updraft condition: sufficient qn and upward velocity\n",
    "        updraft_cond = (w >= w_thresholds[k][1])\n",
    "\n",
    "        if downdrafts:\n",
    "\n",
    "            # Define downdraft condition: sufficient qp and downward velocity\n",
    "            downdraft_cond = (w <= w_thresholds[k][0])\n",
    "\n",
    "            # Combine both conditions: a cell is marked if either is true\n",
    "            mask = updraft_cond | downdraft_cond\n",
    "\n",
    "            # Convert boolean mask to integer (1 for True, 0 for False)\n",
    "            binary_mask = np.where(mask, 1, 0)\n",
    "\n",
    "            # Wrap mask in xarray DataArray with original coordinates and dimensions\n",
    "            da_mask = xr.DataArray(binary_mask, coords=dataset.coords, dims=dataset.dims)\n",
    "\n",
    "            # Store the DataArray in the result dictionary keyed by Ts case\n",
    "            mask_holder_combined[k] = da_mask\n",
    "            \n",
    "        else:\n",
    "            mask = updraft_cond\n",
    "            \n",
    "            binary_mask = np.where(mask,1,0)\n",
    "            \n",
    "             # Wrap mask in xarray DataArray with original coordinates and dimensions\n",
    "            da_mask = xr.DataArray(binary_mask, coords=dataset.coords, dims=dataset.dims)\n",
    "\n",
    "            # Store the DataArray in the result dictionary keyed by Ts case\n",
    "            mask_holder_combined[k] = da_mask\n",
    "            \n",
    "    # Return the dictionary of combined masks\n",
    "    return mask_holder_combined"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "57b12827-bbc6-4b53-bd1a-15e9e3ee7dff",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Processing dataArrays: 100%|██████████████████████| 4/4 [00:02<00:00,  1.35it/s]\n"
     ]
    }
   ],
   "source": [
    "# Cell 6: Compute updraft masks using qn threshold and vertical velocity bounds\n",
    "mask_da_dict = build_draft_mask_condensate_free_dict(\n",
    "    trop_ds_dic,\n",
    "    [(-0.15, 0.7) for i in range(4)],# w bounds per threshold\n",
    "    downdrafts=True\n",
    ")\n",
    "\n",
    "#make the inverse mask, this should be the descending MF\n",
    "mask_da_dict_inv = {j: xr.where(mask_da_dict[j] != 1, 1,0) for j in mask_da_dict}"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8740fefa-b51c-4e3c-91fc-0aa8674cec90",
   "metadata": {},
   "source": [
    "# 7. Compute density"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "94b8b9ec-d534-4b07-8057-9a11c9c7ddfe",
   "metadata": {},
   "outputs": [],
   "source": [
    "def compute_rho(trop_ds_dic,profile=False):\n",
    "    \"\"\"\n",
    "    Compute vertical full density or profiles of air density (kg/m³) for each dataArray.\n",
    "\n",
    "    Parameters:\n",
    "    - trop_ds_dic: dict of xarray.DataArray, keyed by surface temperature (e.g., '280K')\n",
    "\n",
    "    Returns:\n",
    "    - dict mapping temp_case to xarray.DataArray of density profiles\n",
    "    \"\"\"\n",
    "    R_d = 287.05  # J/(kg·K)\n",
    "    rho_dic = {}\n",
    "\n",
    "    for k, da in trop_ds_dic.items():\n",
    "        p_pa = da['pfull'] * 100       # Convert pressure from hPa to Pa\n",
    "        if profile:\n",
    "            T = da         # Temperature in K\n",
    "        else:\n",
    "            T = da\n",
    "        rho = p_pa / (R_d * T)         # Ideal gas law\n",
    "        if profile == False:\n",
    "            rho = rho.transpose('time', 'pfull', 'grid_yt', 'grid_xt')\n",
    "            \n",
    "        rho_dic[k] = rho\n",
    "\n",
    "    return rho_dic"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "7b26338b-e3f4-4c48-82df-8884884f2f7d",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Cell 7: Compute air density using ideal gas law from 3D temp and pressure fields\n",
    "\n",
    "\n",
    "rho = compute_rho(trop_temps,profile=True)  # compute_density \n",
    "rho = {\n",
    "    k: rho[k].to_dataset(name='density') for k in rho\n",
    "}\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "fbf7e44f-003d-4e02-b3b1-cf2f0a33083a",
   "metadata": {},
   "source": [
    "# 9. Final analysis"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "0a8eec43-b5f4-4e7f-91b3-35e64e825e39",
   "metadata": {},
   "outputs": [],
   "source": [
    "#LCL dictionary--mb, z, Tabs\n",
    "LCL_dict = {'280K': [880, 1029, 269], '290K':[909, 803, 281], '300K':[953, 427,295], '310K':[962, 361,306]}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "id": "54e9315c-829c-43e8-987d-e9ea1e57caf7",
   "metadata": {},
   "outputs": [],
   "source": [
    "rho_arrays = {k: rho[k]['density'].values[np.newaxis,:,np.newaxis, np.newaxis] for k in rho}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "id": "7a199633-4847-4331-9566-9b7969e8d79a",
   "metadata": {},
   "outputs": [],
   "source": [
    "MF_net = {\n",
    "    k: (\n",
    "        rho_arrays[k]*\n",
    "        trop_ds_dic[k]['w'].values *\n",
    "        mask_da_dict[k]\n",
    "    ).to_dataset(name='mass flux')\n",
    "    for k in trop_ds_dic\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "id": "d891a1c8-eb8c-4ea1-b936-76d2cb91888f",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(96, 38, 96, 96)"
      ]
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "MF_net['280K']['mass flux'].values.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "id": "fed5ba8f-484e-4af5-91d5-eb6fc75acda1",
   "metadata": {},
   "outputs": [],
   "source": [
    "mf_net = {\n",
    "    k: (\n",
    "        rho_arrays[k]*\n",
    "        trop_ds_dic[k]['w'].values *\n",
    "        mask_da_dict[k]\n",
    "    ).mean(dim=('time', 'grid_yt', 'grid_xt')).to_dataset(name='mf')\n",
    "    for k in trop_ds_dic\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "id": "cb960de9-36ac-4bbc-9812-18858814e3f9",
   "metadata": {},
   "outputs": [],
   "source": [
    "#interpolate mass flux on isobars\n",
    "mf_net_interp_p = iptg(mf_net, 'pfull', np.arange(150, 980,10) )\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "885f117a-968f-43f7-983f-1cc11c46ac62",
   "metadata": {},
   "source": [
    "# This is the money cell where the M_net profiles are made (below)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "id": "8829ae60-0054-47a5-8a3b-90c79efd93ce",
   "metadata": {},
   "outputs": [],
   "source": [
    "sfig = r'...'\n",
    "figname = 'FIG3.pdf'\n",
    "save_fig = os.path.join(sfig, figname)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ef7da9b5-19fd-4675-8037-beaf4a362e72",
   "metadata": {},
   "source": [
    "### Plot of M_net"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "id": "62a54745-9f36-4e1a-a343-1d56f219b83d",
   "metadata": {},
   "outputs": [],
   "source": [
    "def make_mnet_profile_panel(fig=None, position=None, ds_dict=None, xvar=None, \n",
    "                           temp_cases=None, ycoord=None, lcl_dict=None):\n",
    "    \"\"\"\n",
    "    Create M_net profile panel for composite figure.\n",
    "    \"\"\"\n",
    "    # Preview mode\n",
    "    if fig is None:\n",
    "        fig, ax = plt.subplots(figsize=(2.3, 2.2))\n",
    "        preview_mode = True\n",
    "    else:\n",
    "        ax = fig.add_subplot(position)\n",
    "        preview_mode = False\n",
    "\n",
    "    # Validate inputs\n",
    "    assert ycoord in {'zfull', 'pfull', 'temp_profile'}, \"Invalid vertical coordinate\"\n",
    "    assert all(k in ds_dict for k in temp_cases), \"Missing datasets for some temp_cases\"\n",
    "\n",
    "    # Colormap setup\n",
    "    all_temps = sorted([float(t.strip(\"K\")) for t in temp_cases])\n",
    "    cmap = cm.get_cmap(\"viridis\", len(all_temps))\n",
    "    norm = mcolors.Normalize(vmin=min(all_temps), vmax=max(all_temps))\n",
    "    temp_color_map = {t: cmap(norm(float(t.strip(\"K\")))) for t in temp_cases}\n",
    "\n",
    "    # Apply consistent styling\n",
    "    plt.rcParams.update({\n",
    "        'axes.labelsize': 8,\n",
    "        'xtick.labelsize': 7,\n",
    "        'ytick.labelsize': 7,\n",
    "        'legend.fontsize': 8\n",
    "    })\n",
    "\n",
    "    all_x_vals = []\n",
    "\n",
    "    # Plot profiles\n",
    "    for temp_case in temp_cases:\n",
    "        ds = ds_dict[temp_case]\n",
    "        x_data = ds[xvar].mean(dim='time') if 'time' in ds[xvar].dims else ds[xvar]\n",
    "        y_data = ds[ycoord]\n",
    "\n",
    "        # LCL masking\n",
    "        if lcl_dict:\n",
    "            threshold = {\n",
    "                'zfull': lcl_dict[temp_case][1],\n",
    "                'pfull': lcl_dict[temp_case][0],\n",
    "                'temp_profile': lcl_dict[temp_case][2]\n",
    "            }[ycoord]\n",
    "            mask = (y_data < threshold) if ycoord in {'pfull', 'temp_profile'} else (y_data <= threshold)\n",
    "        else:\n",
    "            mask = slice(None)\n",
    "\n",
    "        color = temp_color_map[temp_case]\n",
    "        ax.plot(x_data[mask].values, y_data[mask].values,\n",
    "                color=color, linewidth=1.5, label=temp_case)\n",
    "        all_x_vals.extend(x_data[mask].values.tolist())\n",
    "\n",
    "    # Axis labeling\n",
    "    coord_labels = {\n",
    "        'zfull': \"Altitude (m)\",\n",
    "        'pfull': \"Pressure (hPa)\", \n",
    "        'temp_profile': \"Isotherm (K)\"\n",
    "    }\n",
    "    \n",
    "    ax.set_ylabel(coord_labels[ycoord], fontsize=9)\n",
    "\n",
    "    # 500 hPa reference line\n",
    "    if ycoord == 'pfull':\n",
    "        ax.axhline(500, color='gray', linestyle='--', linewidth=1.0)\n",
    "\n",
    "    # Invert y-axis if needed\n",
    "    if ycoord in {'pfull', 'temp_profile'}:\n",
    "        ax.invert_yaxis()\n",
    "\n",
    "    # Symmetric x-axis\n",
    "    x_max = np.nanmax(np.abs(all_x_vals))\n",
    "    ax.set_xlim(0, x_max + 0.0015)\n",
    "    ax.xaxis.set_minor_locator(ticker.MultipleLocator(0.001))\n",
    "\n",
    "    # Legend\n",
    "    ax.legend(loc='upper right', \n",
    "          bbox_to_anchor=(0.99, 1), frameon=False)\n",
    "\n",
    "    # Spine formatting\n",
    "    for spine in ax.spines.values():\n",
    "        spine.set_linewidth(1.0)\n",
    "\n",
    "    if preview_mode:\n",
    "        plt.show()\n",
    "\n",
    "    return ax"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "id": "0857ab1c-d6c2-47cf-a8ff-cdcfe394151c",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/var/folders/9y/5mwh84_d1r9_4v5h12d_jz6m0000gn/T/ipykernel_4184/2723196267.py:20: MatplotlibDeprecationWarning: The get_cmap function was deprecated in Matplotlib 3.7 and will be removed in 3.11. Use ``matplotlib.colormaps[name]`` or ``matplotlib.colormaps.get_cmap()`` or ``pyplot.get_cmap()`` instead.\n",
      "  cmap = cm.get_cmap(\"viridis\", len(all_temps))\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 230x220 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": [
       "<Axes: xlabel='M_net [kg m$^{-2}$ s$^{-1}$]', ylabel='Pressure (hPa)'>"
      ]
     },
     "execution_count": 36,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "make_mnet_profile_panel(ds_dict=mf_net, xvar='mf', temp_cases=list(mf_net.keys()) ,ycoord='pfull', lcl_dict=LCL_dict)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "cb1835c7-6690-4721-b6b6-515e3f2b39ab",
   "metadata": {},
   "source": [
    "### Function make plot of prec masked to MF"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "id": "0f92cd38-b204-46c8-91d1-d548c0ceacc1",
   "metadata": {},
   "outputs": [],
   "source": [
    "def make_masked_precip_panels(fig=None, positions=None, precip_data_dict=None, \n",
    "                             temp_cases=None, time_steps=None):\n",
    "    \"\"\"\n",
    "    Create two masked precipitation panels with shared colorbar.\n",
    "    \n",
    "    Parameters\n",
    "    ----------\n",
    "    fig : matplotlib.figure.Figure, optional\n",
    "        Figure to plot into. If None, creates new figure for preview.\n",
    "    positions : list, optional  \n",
    "        List of two GridSpec positions for the panels. If None, creates subplots.\n",
    "    precip_data_dict : dict\n",
    "        Dictionary of DataArrays keyed by surface temperature.\n",
    "    temp_cases : list of str\n",
    "        Two temperature cases to plot, e.g. ['280K', '290K'].\n",
    "    time_steps : list of int\n",
    "        Two time step indices, one for each temperature case.\n",
    "    \n",
    "    Returns\n",
    "    -------\n",
    "    dict\n",
    "        Contains 'axes' (list of two axes) and 'cbar_ax' (colorbar axis).\n",
    "    \"\"\"\n",
    "    # Preview mode\n",
    "    if fig is None:\n",
    "        fig, axes = plt.subplots(1, 2, figsize=(8, 3))\n",
    "        ax1, ax2 = axes\n",
    "        preview_mode = True\n",
    "    else:\n",
    "        ax1 = fig.add_subplot(positions[0])\n",
    "        ax2 = fig.add_subplot(positions[1])\n",
    "        preview_mode = False\n",
    "    \n",
    "    # Extract and plot data\n",
    "    norm = LogNorm(vmin=1, vmax=2000)\n",
    "    \n",
    "    for i, (temp_case, time_step) in enumerate(zip(temp_cases, time_steps)):\n",
    "        ax = ax1 if i == 0 else ax2\n",
    "        \n",
    "        # Get data for this temperature case and time step\n",
    "        da = precip_data_dict[temp_case].isel(time=time_step)\n",
    "        \n",
    "        # Plot with masked regions\n",
    "        im = ax.imshow(da.values, cmap=cmocean.cm.rain, norm=norm,\n",
    "                      origin='lower', interpolation='nearest', aspect='auto')\n",
    "        \n",
    "        # Set title with temperature\n",
    "        ax.set_title(f\"$T_s = {temp_case[:-1]}\\,K$\", fontsize=9)\n",
    "        ax.tick_params(bottom=False, left=False, labelbottom=False, labelleft=False)\n",
    "    \n",
    "    # Add shared colorbar to the right of the second panel\n",
    "    if not preview_mode:\n",
    "        # Create colorbar axes to the right of ax2\n",
    "        divider = make_axes_locatable(ax2)\n",
    "        cax = divider.append_axes(\"right\", size=\"5%\", pad=0.1)\n",
    "    else:\n",
    "        # For preview, create colorbar on the figure\n",
    "        cax = fig.add_axes([0.88, 0.11, 0.02, 0.77])\n",
    "    \n",
    "    cbar = fig.colorbar(im, cax=cax)\n",
    "    cbar.set_label('mm/day', fontsize=9)\n",
    "    cbar.set_ticks([1, 10, 100, 1000,2000])\n",
    "    cbar.set_ticklabels(['1', '10', '100', '1000','2000'])\n",
    "    \n",
    "    if preview_mode:\n",
    "        plt.show()\n",
    "    \n",
    "    return {'axes': [ax1, ax2], 'cbar_ax': cax}"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "92a484ff-ad1a-4c31-ad82-9051e6d31817",
   "metadata": {},
   "source": [
    "### Variables needed to make masked prec"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "id": "c3cbc02b-30db-4aff-991e-eecbb82691bc",
   "metadata": {},
   "outputs": [],
   "source": [
    "#Run M_net_proyection_2D_surf.ipynb to brin this dictionary in\n",
    "%store -r lpf_masked_prec"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1c6d79fd-20ec-4617-a178-fceefca50bcb",
   "metadata": {},
   "source": [
    "## Function to make second row"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "id": "3cc727a6-962d-4c3e-ac8f-422dac8ec57e",
   "metadata": {},
   "outputs": [],
   "source": [
    "def make_metrics_panels(fig=None, positions=None, df=None, ds_mf=None, delta_dic=None,\n",
    "                       na_uncertainty=None, mf_uncertainty=None, delta_uncertainty=None):\n",
    "    \"\"\"\n",
    "    Create three metrics panels for bottom row of composite figure.\n",
    "    \"\"\"\n",
    "    # Preview mode\n",
    "    if fig is None:\n",
    "        fig, axes = plt.subplots(1, 3, figsize=(7, 2.2))\n",
    "        ax1, ax2, ax3 = axes\n",
    "        preview_mode = True\n",
    "    else:\n",
    "        ax1 = fig.add_subplot(positions[0])\n",
    "        ax2 = fig.add_subplot(positions[1]) \n",
    "        ax3 = fig.add_subplot(positions[2])\n",
    "        preview_mode = False\n",
    "\n",
    "    temps = [280, 290, 300, 310]\n",
    "    temp_labels = [f\"{T}K\" for T in temps]\n",
    "\n",
    "    # Colors\n",
    "    cmap = plt.cm.get_cmap('viridis', len(temps))\n",
    "    colors = [cmap(i) for i in range(len(temps))]\n",
    "    color_na = 'purple'\n",
    "    color_mf = 'teal'\n",
    "\n",
    "    # Extract and process data (same as before)\n",
    "    na_vals = [df.loc[df['Ts'] == T, 'all_area_m1'].values[0] for T in temps]\n",
    "    mf_vals = [ds_mf[str(T)+'K'].sel(pfull=500, method='nearest').values.item() for T in temps]\n",
    "    \n",
    "    delta_keys = ['280-290K', '290-300K', '300-310K']\n",
    "    delta_vals = [delta_dic.get(k, np.nan) for k in delta_keys]\n",
    "    delta_norm = [1.0]\n",
    "    for i in range(1, len(temps)):\n",
    "        cumulative_delta = sum(delta_vals[:i])\n",
    "        delta_norm.append(np.exp(-cumulative_delta))\n",
    "\n",
    "    na_norm = [v / na_vals[0] for v in na_vals]\n",
    "    mf_norm = [v / mf_vals[0] for v in mf_vals]\n",
    "\n",
    "    # Apply LaTeX-appropriate styling\n",
    "    plt.rcParams['text.usetex'] = False\n",
    "    plt.rcParams['font.family'] = 'serif'\n",
    "\n",
    "    # Panel 1: Mass Flux (NO TITLE)\n",
    "    ax1.bar(temp_labels, mf_vals, color='none', edgecolor=color_mf, linewidth=2)\n",
    "    if mf_uncertainty:\n",
    "        err = [mf_uncertainty.get(T, 0) for T in temps]\n",
    "        ax1.errorbar(temp_labels, mf_vals, yerr=err, fmt='none', color='gray', capsize=4)\n",
    "    ax1.set_ylabel(r\"Net Mass Flux at 500 hPa [kg/m$^2$s]\", fontsize=8)\n",
    "    ax1.ticklabel_format(style='sci', axis='y', scilimits=(-2, 2))\n",
    "    ax1.set_ylim(0, max(mf_vals) * 1.1)\n",
    "\n",
    "    # Panel 2: Area Fraction (NO TITLE)\n",
    "    ax2.bar(temp_labels, na_vals, color='none', edgecolor=color_na, linewidth=2)\n",
    "    if na_uncertainty:\n",
    "        err = [na_uncertainty.get(T, 0) for T in temps]\n",
    "        ax2.errorbar(temp_labels, na_vals, yerr=err, fmt='none', color='gray', capsize=4)\n",
    "    ax2.set_ylabel(\"Fract. area w/convective rain\", fontsize=8)\n",
    "    ax2.ticklabel_format(style='sci', axis='y', scilimits=(0, 0))\n",
    "    ax2.set_ylim(0, max(na_vals) * 1.1)\n",
    "\n",
    "    # Panel 3: Normalized Comparison (NO TITLE)\n",
    "    ax3.plot(temp_labels, mf_norm, '--s', label=r'$M_{net}$', color=color_mf, linewidth=2, markersize=5)\n",
    "    ax3.plot(temp_labels, na_norm, '-o', label=r'$A_c$', color=color_na, linewidth=2, markersize=5)\n",
    "    ax3.plot(temp_labels, delta_norm, '-.^', label=r'$d$', color='mediumseagreen', linewidth=2, markersize=5)\n",
    "    ax3.set_ylabel(\"Normalized comparisons\", fontsize=8)\n",
    "    ax3.legend(loc=\"upper right\", bbox_to_anchor=(1.05, 0.98), frameon=False, fontsize=8)\n",
    "\n",
    "    # Universal formatting\n",
    "    for ax in [ax1, ax2, ax3]:\n",
    "        ax.set_xlabel(\"\")\n",
    "        ax.tick_params(labelsize=7)\n",
    "        ax.grid(False)\n",
    "\n",
    "    if preview_mode:\n",
    "        plt.show()\n",
    "\n",
    "    return [ax1, ax2, ax3]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "70388662-66ec-48e6-aa8f-5e1afbea999e",
   "metadata": {},
   "source": [
    "### Variables needed to make second row"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "id": "d41dd32c-4ea5-4ad6-8fd4-1d5580ab1d28",
   "metadata": {},
   "outputs": [],
   "source": [
    "%store -r df ds_mf delta_dic"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "da408bab-d4fa-4b4d-82d1-8bacfaffcf40",
   "metadata": {},
   "source": [
    "### Plot that brings it together"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "id": "ff0e61b4-236d-4a07-b4e2-282a7a555ded",
   "metadata": {},
   "outputs": [],
   "source": [
    "import matplotlib.cm as cm\n",
    "import matplotlib.colors as mcolors\n",
    "import matplotlib.ticker as ticker"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "id": "91c9e6cd-c0e2-4d17-b723-2099785bb05b",
   "metadata": {},
   "outputs": [],
   "source": [
    "from matplotlib.gridspec import GridSpec\n",
    "from matplotlib.colors import LogNorm\n",
    "import cmocean\n",
    "from mpl_toolkits.axes_grid1 import make_axes_locatable"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "id": "698ffdcf-e55e-4f7c-9ed6-fdd439957dd3",
   "metadata": {},
   "outputs": [],
   "source": [
    "save_loc = r'...'\n",
    "sdir = os.path.join(save_loc,'FIGURE4.pdf')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "id": "976358a9-77b1-4853-9d5c-8aab3a5117db",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/var/folders/9y/5mwh84_d1r9_4v5h12d_jz6m0000gn/T/ipykernel_4184/1061233767.py:20: MatplotlibDeprecationWarning: The get_cmap function was deprecated in Matplotlib 3.7 and will be removed in 3.11. Use ``matplotlib.colormaps[name]`` or ``matplotlib.colormaps.get_cmap()`` or ``pyplot.get_cmap()`` instead.\n",
      "  cmap = cm.get_cmap(\"viridis\", len(all_temps))\n",
      "/var/folders/9y/5mwh84_d1r9_4v5h12d_jz6m0000gn/T/ipykernel_4184/2089470847.py:21: MatplotlibDeprecationWarning: The get_cmap function was deprecated in Matplotlib 3.7 and will be removed in 3.11. Use ``matplotlib.colormaps[name]`` or ``matplotlib.colormaps.get_cmap()`` or ``pyplot.get_cmap()`` instead.\n",
      "  cmap = plt.cm.get_cmap('viridis', len(temps))\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Composite figure saved to: /Volumes/COO/MFP_NJ/RESULTS/FIGS/FOR_PAPER/FIGURE4.pdf\n"
     ]
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAApwAAAIICAYAAADDvD7wAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjkuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8hTgPZAAAACXBIWXMAAA9hAAAPYQGoP6dpAAEAAElEQVR4nOzdeVhU1RvA8e8d9n0TBBVFQBA3cF/Q3HLfy7W0NC0116wszSzLNZdMrbRSK/u5ZJuaplYumRvu+4aK4goCsq8z9/fHhYkR0BkYGJDzeZ55ZO7cOffMMODLe855jyTLsowgCIIgCIIgFBOVqTsgCIIgCIIgPN1EwCkIgiAIgiAUKxFwCoIgCIIgCMVKBJyCIAiCIAhCsRIBpyAIgiAIglCsRMApCIIgCIIgFCsRcAqCIAiCIAjFSgScgiAIgiAIQrESAacgCIIgCIJQrETAKQil2Ouvv46trS2SJCFJEh9++KGpuyQIgiAIBhMBpyCUYl988QVffPGFqbtRKq1btw57e3vs7e21QXnOfXt7ezZu3Gi0a6Wnp/Pqq69SvXp1HBwcqFmzJqtWrdI55/bt2/Tu3Rs3NzcqVKhA//79iY6O1j6emZnJ2LFjcXFxwdXVlXHjxpGVlZXnWpmZmVhbW7Nr1y7tsS1btuDh4cGyZcuM9pqEsqMkP+sA48aNw9vbG0dHRypXrszEiRPJyMjQPr5s2TIaNWqElZUVvXv3zvN88VkX8iULglCqrV69WgZkQP7ggw9M3Z1Sad26dXLlypWLrf2kpCT5/fffl8PDw2WNRiMfPHhQdnZ2lnfs2KE9p1evXnKvXr3kxMREOSEhQe7Ro4c8cOBA7ePTp0+Xg4OD5Tt37sh37tyRg4OD5RkzZuS51okTJ2RJkuSHDx/KGo1G/uCDD+RKlSrJ//77b7G9PqHsKO7PuizL8vnz5+WkpCRZlmU5OjpabtOmjfzxxx9rH//555/lX3/9VR4zZozcq1evPM8Xn3UhPyLDKQhCmXfixAkaNGhQbO3b2dnx0Ucf4efnhyRJNGvWjLZt2/Lvv/9qz7l27Rr9+/fH3t4eBwcHBgwYwJkzZ7SPr1q1imnTpuHl5YWXlxfvvfceK1euzHOt48eP4+/vjyzL9OjRg507d3L06FFCQ0OL7fUJZUdxf9YBgoKCsLOzA0CWZVQqFVeuXNE+/txzz9G7d28qVKiQ7/PFZ13IT6kOOH/44QeeffZZbWrf0dGRxo0bs3TpUjQajam7JwglLiIigs6dO+Pk5IS9vT2dOnXi5MmTpu6WyR0/fpz69evrff7rr7+Os7NzgbfcgWR+0tLSCAsLo169etpjkyZNYuPGjcTHx/Pw4UPWrVtHjx49AIiLi+PWrVuEhIRozw8JCeHmzZvEx8fneS329vY0btwYb29v9uzZg5eXl96vrTzatWsXXbp0wdXVFRsbG/z8/OjcuTMLFy7Mdyi3LCupz/rcuXOxt7fHw8ODU6dOMW7cOL2uJz7rQoFMnGF9rG7duslDhgzRpvZ37dolW1lZyYD81ltvmbh3glAycg+pOzk5yefOnZMTEhLkJk2ayIBsb28vX7p0ydTdNCk3Nzf5t99+K5FraTQa+cUXX5TbtGkjq9Vq7fHLly/LLVq0kCVJkiVJklu0aCHHx8fLsizLN2/elAE5Ojpae35UVJQMyJGRkTrtN2/eXHZ1dZUDAwPljIyMEnlNZdmqVatkSZJkQB46dKickJAgp6enyxMmTJABOS4uztRdNKqS/KzLsjK8/t577+X5nMqyLH/wwQd5htTFZ10oSKnOcH7xxRd8+eWX2tR+27ZttX81ffHFF2RmZpqwd4JQ8rp06UKtWrVwcHBg+PDhACQlJTFr1iwT98x0bt68SUxMTLEPM4IyvPj6669z6dIlfvvtN1Qq5VeoRqOhQ4cOhIaGkpSURFJSEqGhoXTs2BEAe3t7AJ0MT87XDg4O2mNqtZpTp07x7bffYm9vz8iRI4v9NZVlSUlJvPHGG9ph30WLFuHg4IClpSXz5s3DxsbG1F00qpL8rOcICgoiODiYoUOH6nW++KwLBSnVAadarWbs2LH4+vpib2+Ps7MzR48eBSAlJYWoqCgT91AQSlbVqlW1X3t7e2u/3rNnjwl6UzocP36cChUq6LwfarWakSNH0qZNG0JDQ/MMG44aNUpnle+jt3379uW5jizLjBkzhsOHD7Nz506cnJy0j8XGxnLjxg3Gjx+Pra0ttra2jBs3jsOHD/PgwQNcXFyoUqWKzvSHkydP4u3trdPOxYsXSUlJoWXLlmzatInt27czb948I75bT5cDBw5ogxkvLy9cXFy0j1lZWXH//n2d97esK6nP+qMyMzN15nA+jvisCwUxN3UHCpKYmEjLli25c+cOXl5eHD16lJo1a9KmTRv27t0LIDKcQrmTO2NjZWWl/To2NtYU3SkV8pvTdvr0aRITE7WB+KNzvpcvX87y5csNus7YsWPZv38/u3bt0glsACpUqIC/vz+ff/45H3zwAQCff/45VapU0S6sGDZsGLNmzdIuiJg9ezYjRozI81p8fHxwcXHBxcWFTZs20aZNGwIDA/MtP1Pe5S47lTMSllvujNrToCQ+60lJSWzcuJE+ffrg5OTE2bNnmTlzJp06ddKek5WVpb1pNBrS0tJQqVRYWloC4rMu5K/UZjh3797NnTt3AOjXrx81a9Y0cY8EwfRSU1O1X6enp2u/dnV1NUV3SoX8Vu3WrVsXf39/+vXrx4oVK7RD34V148YNvvjiCy5dukS1atW02aFRo0Zpz9m0aRPHjx+ncuXKeHl5ERYWxubNm7WPv//++zRv3pygoCCCgoIIDQ1l6tSpOtc5fvy4zmtp3LgxK1euZPDgwRw/frxIr+Fp5O7urv06OTnZhD0pGSXxWZckibVr1+Ln54eDgwO9evWiW7duLF68WHvOzJkzsbGxYdasWWzZsgUbGxvt9BEQn3WhACaeQ1qgX375RbtQ4u2339Yeb9Cggfb49evXTddBQSghuRcN5a7r+NVXX2mPv/TSSybsYemTnJwsy7IsZ2VlyX5+fibujVBcEhMTZScnJxmQVSqVHBsbq30sMjJSrlixonzhwgUT9rD4ic+6UFaU2gxn48aNtUOGO3bsICUlhX///ZdTp06ZuGeCYDp//PEHFy5cIDExUbvTjb29fZ7sQXn3yiuvEBoaStOmTZkyZYqpuyMUE3t7ez799FMkSUKj0fDWW2+RnJxMUlISb775JsHBwU/96Jj4rAtlhSTLsmzqThRk48aNvPfee9y4cQNfX1+GDx/O5s2btZOcHRwcWL58OS+88IKJeyoIxeP111/n22+/1Q6lDx8+nFu3bnHgwAE0Gg0tWrRg3rx5BtXlE4Snze7du1m4cCGHDh0iOTmZSpUq0bNnT2bMmIGjo6OpuycIAqU84BQEQRAEQRDKvlI7pC4IgiAIgiA8HUTAKQiCIAiCIBSrUluH0xBbt25l+/bt2NnZ4ePjo1OqRBAEQRAEoaw5e/Yss2fPpkGDBly5coUmTZowfPhwwsPDmTNnDn5+fkRFRbFgwQLMzc2Jiopi6tSp+Pn5cePGDRYsWIC9vT3Jycm89dZbVK1alfDwcGbPnk3FihVL/PWU+TmcSUlJNGjQgPPnz2Nubk7z5s354Ycf8PPzM3XXBEEQBEEQCmX37t2Asq13ZmYmFStW5OrVq/Tr14+FCxcSHBzM5MmTCQoKYtiwYYwYMYIePXrQq1cvvvjiC+7fv8+MGTOYOXMmDg4OTJgwgW3btrFhwwa+++67En89ZT7g/Ouvv5g/fz47duwAYPz48QQGBjJmzBid89LT03UKZT948IB9+/bh7+//1O23K5hWamoqERERdOrUSbvLTGmn0Wi4c+cODg4OSJJk6u4ITxFZlklMTKRSpUpFLkpeUsTPg5AfQz7LaWlpZGRk5NvGo58pKysrnZ3j8pOZmUmVKlW4fPkyXl5epKSkAPDLL7+wbt06Nm7cSJUqVThy5AheXl4cP36ckSNHcuTIEVq2bMn8+fNp3rw5sbGxBAYG6uzSVVLK/JB6dHS0zvZljo6O+b6Rc+bMYcaMGSXZNaGc++GHH3jxxRdN3Q293LlzR2d/ZkEwtsjISKpUqWLqbuhF/DwIj/Okz3JaWhr2do6oNXm337a3tycpKUnn2AcffMCHH3742Gt++eWXTJ06lZSUFGxtbbXHc8c8ueOhxx2PiYlBo9GU+B+AZT7gdHd3JzExUXs/ISGBwMDAPOdNmTKFSZMmae8fOnSITp068cMPPxAUFFQifRXKhwsXLjB48GB8fHxM3RW95fwyajJ9GNcyLLk65RMT90jXW98phe13xWTxQmVlz+y3BnxQ5HaP7VoJQMVqz1DFr0aR2zOluNhEXFz12zs8Lva/35n6PqewEhIS8Pb2LlP7muf0NTIy8qmp4/npho94Y8B0k10/6s49rp37DYBmHfKus8j5TPb+4WMuXVCTsy1NNX8z1rfvg0uVOkDxf14fR9/PckZGBmpNJlU9G6BSmWmPazRqbt47nudz9aTs5s8//0xiYiLvvfceGRkZ2uxmTp9ytnjNiYfs7e3zPZ5zvpubm0lGG8p8wNmsWTOuX79OVlYW5ubmHDlyhAkTJuQ579GUdc5QZ1BQUJ69aQXBGMrSVI2cIZ4/31yMo6Mjf29bBECDZq+a9Bc8KP8RTQx5BoCK147xaugrAKizlD4Xtn/jv3kLDysLAAZJqWU+sDCk/6Z4rWVpaDqnr46OjmX+c5Hjg1cXmPT6jo6O+NecXODjOT/P69t35w+/w5xNSAagpZsz1Wq1IP7+tex2Kud57vbf5wPgbuVEww6vGbvreej7WVaZmaNS5QqzCvG5Wrt2LXfv3uW9997j1KlT2NjY0KJFC06dOkVwcDCHDh2ia9euAHTu3JmwsDB69eqV7/HmzZvrHC9pZT7gtLe3Z9GiRYwfPx47OztefvllsWBIEARBEATTkrJvue8bYPfu3YwePZr69euzZcsWHjx4wLJly1i+fDmzZs3C19eX9PR0hgwZAsDs2bOZMmUKp0+fJjIykkWLlMTBG2+8wZtvvsnMmTO5du0a8+bNM87rM1CZDzgBunfvTvfu3U3dDUF4arTvqkw/iQy/hIurMkXlndWTqWBpCcDbL84ssb64uDpA7S4AjK/RFndPd6O0u+V+Bm5WyqT+aUNaGvTcnOG/wmZXjfX83IydiS5qHwXBENrPWWBrXg5srfPYrdObOBN7AwBrhwok3b8EgCxrSIi7xtVkZU6kJtcS6Ec/v9fPHaN67YbF+RLykFQqpFxD15KBpc/btm1LfHx8vo+tXr06zzEPDw9WrlyZ57idnR3Lly836NrF4akIOAVBEARBEEoVSdIOo2vvl2Mi4BQEQRAEQTC2Ig6pP21EwCkIQoG8/QN5ZcUbAGTJYGdm9oRnFM6Thm//O2684d0GzhIZGv378Oh5TzsxlF6+XT68Xfk36jROFta06jy+RK7r4uqQ52dMpTLnQYZSR3vzgW84m6A8fi89C5UEliolkruXlkb1f38BwLNWBz77fRarb6YC0LqCisWeSiUKV7cSWggmMpw6RMApCIIgCIJgZJIkIan+CzIlWQScgiAI+bp+9iirRn4KwOJ17+OeXVps3/YlAEbLejyaTSvOOpE5bf885jOdY4ZkNovaJ2M9v7xkW4WSF9C0MwBtP/6D2+9/9oSzi8/tM1vYcfs8ux5k15FUy5yNUwK3lDSwsgRvh5yhigyux10FwDaqBkuvppJ2MwuAtfdUVLZWFjtO7vk+UAJZfJHh1FE29hkThFxiYmIYNmwY48aNY/z48fTs2ZPw8HAAwsLC6Ny5M5MmTeL555/n888/1z4vIyODESNGMGLECHr16sXGjRsByMrKYtSoUUiSxIABA7h58ybXr1+nTp06dOrUiT/++MMkr1MQBEEow3ICzty3ckxkOIUyJzIyEhsbG5YuXQrA0qVLGTFiBHv27GHcuHGMHDmSV155hZSUFFxdXencuTN+fn589tlnWFhY8OWXX5KUlERgYCCtWrXC09OT5cuXs2LFCt5//32qVq3KihUr6N+/P9Onm25njtKgep1G2q8nDvq4WK4RF5vIl9vmAPAgXdkKbnTdDtRo0rFYrpdfVkOfTMeTsoqtPlWyvTVszbRZ4eJWkplhoXxpvlD5PFe1henfvctHL88tUnuL1r7PpBcK/h1y9dQBAPyCWxBz/QhhNw4CsO1+NH/ck0m4r2QxJVlGyi5/ZJYlk2JvRoK1EsjdSlOz+d5dAOIyNzHCx4ol6dkXSJe5nqKUQbt58me2373COy/OAmDNzzMZ8vw0bV8mrXybRcPnF+n1KsSqodxEwCnoTZZl0lLSn3xiEVjbWj1xF4eQkBCdzKWvry+3b98GoHLlyty/fx9QMqFqtRpZVn47rVmzhtmzZwPKhgHNmzdn/fr1TJw4UduWLMtMmzaNgICAch9sCoIgCEUg4k0dIuAU9JaWkk5PhyHFeo3NiWuwsbN+4nm5g9ItW7YwZswYAL766it69erFpUuXOHHiBCtWrMDf3x+AiIgIPD09tc+rWLEi169f12l3xIgRjB07Vrtzg1B8crJxMdePsCtGKdxcxUpZBZ+VnqA9b+w3b7JsxMKS72ABCsoc7ntjSYn1oaAV9YZkNUVhd6EgkeGXaOmq/B5WAW/0eK/IbeaX3cydkfcLbgHAlbCdnLpzjAOxsQAci9cQnwDu0cpqc4sMNZmWyu8JSYZYM2seJCn307MkriSpAdgfF0VVa4khvspjliqJECdldfrpuFtsuJPIrGnKNtgJM3XnqD7Myiry6wXgkcLv2g3iy6ny/eqFMm/r1q2kpKQwYYLyi6NHjx6MGjWKb7/9lr/++ovPP/+cW7du6d1elSpVmD59OhEREcXUY0EQBKFcEHM4dYgMp6A3a1srNieuKfZr6Gvr1q1s2rSJ1atXI0kS0dHRHDp0iC1btgDg7u6Op6cnP/74I5MmTcLHx4d79+5pn3///n1CQ0N12pwxYwbr16+ndevW7Nq1Cz8/P+O8sDKmJLJf/7XdmL8atgNg82Zlj1/P2p2051lKKpasV6Y3jB/4UbH1pyzJPZ+0sN8jkdkUCuLtH8h8/08AaLd4fLF9VvJrV52VRkJWJhnZ+1RqAHNLCTm7vJAqS4119lxvs/R01GYqYqyV/zdikwFz5bwH1hJJ9jLpspKtrGNvSVJ25tLN1ooOFayBtHz7ZbQ52GJIXYfIcAp6kyQJGzvrYr09af5mjo0bN7Jz505WrFiBmZkZEyZMwM3NjQoVKnD+/HkA1Go1ly5domrVqgAMHjyYrVu3ApCUlMTBgwcZOHBgnrZnzpzJ0KFDad26NZcvXzbSuycIgiCUK0XMcF67do0+ffro/D8VHh7O8OHDmT17NhMnTiQrO4iOiopixIgRzJkzh1GjRpGUpExTSk5OZvTo0cyZM4fhw4dr1ziYggg4hTLn9OnTDBo0iA0bNuDl5YWnpydfffUVKpWKn376idmzZ/PGG2/Qt29f+vXrx/PPPw/AhAkTSE9PZ/jw4bzwwgssXLgQLy8vsrKyGDt2LACzZ8/m5s2bzJgxg9dee402bdowdepUU75cQRAEoSwqYsB5+PBhOnfurHNs1KhRjB8/nqlTp2JpacmaNcqo49SpU+nRowdTpkyhXr16zJ+vrLL/9NNPqVmzJlOmTOH5559n8uTJxnlthSDJOUt4y5njx4/TsGFDjh07RoMGDUzdHeEpUhY/WwkJCTg5OfHqkjHEqMwYULkiAB2eGacz7PW4ofailOR5tNTQ0z7cW9gpC+99+47y/Ewlq/HFq8ZdTGXsqRThx3aRmJRMgzY9iY+Px9GxhLYULKKcn4ey1OenRVxsIvfO7WDXnTMA/HovjrtpcOmWEqq43UvHNiEFALP0TOIrOpNhqeTOVBqZVFtlpmCWlYStswp/J+V5DRzNqeVgB0Bzt4q4e9QjLUGZ3+8R8CweXh5P7Ju+n4uc83zrPouZ2X8zF9XqLK6d+YvIyEid51tZWWFllf90sm+//Zbt27ezfv16MjIycHZ2JiVFef2//PIL69atY+PGjVSpUoUjR47g5eXF8ePHGTlyJEeOHKFly5bMnz+f5s2bExsbS2BgINHR0U98rcWh3Gc4ZfUDU3dBEARBEISnjcQjGU7lsLe3N05OTtrbnDlz9GouJiYGW1tb7X1HR0dt8BgdHY2Dg8MTj8fExKDRaDCFcr9oSE6YhpxVC8m8iqm7IggmtysmizvpZiSrlcVVwZf24tK8u/bxoma+Lh/aBoB7QCudtp62jOaTMsGFfb0Z2QNSFSwtCt85PTyuj4ZkQTde+Ju01OKt3Ss8XVxcHaB2J9qrlPAkIuUAKtK476rkx+LTLLFOVj5TKikLq7RMrLI/YulWFlinKmWRMjQqUiwkUu2z27U0p5V7ZQD8G75YMr9zCtjaMr8Mpz7c3Ny02U1QMqnu7u6Askg2MTERe3v7fI/nnO/m5oZKZZpcY7nPcKK+hxz7AnLmWVP3RBAEQRCEp0UBczgdHR11bvoGnJaWlrRo0YJTp04BcOjQIbp27QpA586dCQsL0/u4KZT7DCdmVUBzDzlmADhOBZsX9F4pLQhPG1mGjGSZcwnKz8CZ+2fwiG0N6Ga0Iq8qq/e9/QK0x/TJGHx9YQ8A85uZ7pdeYRlrfmNRnj+x7WgAKvtUL1IfCpJf325HXGfgr0qZmIhkiY9rugHQq90bBT4H4M1VbxOfqSZDZDiFQrByUkYdnczNcLVQUdVeGQa+623GHQslO+gYl0mGpQpNdskktbmESq2MAqjNJFRm4JA9GBDkYI+nbztt+yWyDaxKUm45ZOXrxo0bY2ZmxpgxY7SbluRn69atbNmyhStXrrBkyRLGjx/P8uXLmTVrFr6+vqSnp2s3KZk9ezZTpkzh9OnTREZGsmjRIgDeeOMN3nzzTWbOnMm1a9eYN29e8bxWPZT7gFNymgtW6yH9L+SEGZARBo4zkFTOpu6aIAiCIAhlVQFD6keOHNFrMVq3bt3o1q2bzjF/f39Wr16d51wPDw9WrlyZ57idnR3Lly83sOPFQwScKnsk588hZTVy4gJI+wM54yg4zkSybmvq7glCiarnIGFpAxfeVbZ6O7Xr23z/+rdz9sxzDHS3q/TPLua+Y+sCAI7ExnAsXim0vPaXWbzwXNG3yyuMwmYqDTm/uDImto4ViqXdx6nsU52eHsp/jucSk/G1c9LrebZmKipbW5NmVu7/mxEM5OLqQFKs8jPka2dPbEYWsZlKplyDDJ7KbMCHTlaYSZCzE6U647+iO2aWEu4O0NLZEoAQZy/sXbx0rlH8Hi2FVL5HT8UcTpSC5pLdK0iu68DMFzTRyA9Hool/F1mT8OQGBEEQBEEQdEj53Mov8adnLpJlMFT4DTlxMaSshtRfkNP3g9PHSFZtTN09IVtMTAxvvfUW9vb2SJJEREQEixYtwt/fn7CwMObOnYuvry+3bt1i1KhRtGnTBoCMjAxef/11QCkVMXjwYPr166ct/L5ixQr69+/P/PnzUavV9OjRg8qVKzNx4kS6dOliwldccrpUdKOzlTkX9/8GgEvlxvme5+qWdzgo95wo/4bt6LFU2d++lr0yIb5P5WpcTLoCQGyG6ef1FWW1uKmYqr9vvzgTgJuXzlE1sLZez/n45Xlc+PcXkpJTME0uWyjLvP0DAXC+YIm9uRmVrMwAUElqMrO3vVRlZw+z72KukvCxy34MmcrWKpq4OgNQvcF/u/WU2M9RAUPq+s7hfNqIgPMRkmSN5PgusvWzyPFTQR2BHPcasnUfJMepSCr9hpOE4hMZGYmNjQ1Lly4FYOnSpYwYMYLdu3fTu3dvfvrpJ1q0aMHDhw8JCgri4sWLODk58dlnn2FhYcGXX35JUlISgYGBtGrVCk9PT5YvX86KFSt4//33qVq1qjb4nD59uolfrSAIglAmPbpoSGXYHM6njQg4CyBZNoIKm7Kznd9C2q/IGQfAaR6SVQtTd88kZFkmLSOrWK9hbWn+xCoBISEhfP7559r7vr6+3L59m5iYGO7evUtAgLJy2tnZGTs7O7Zt28agQYNYs2YNs2fPBsDe3p7mzZuzfv16Jk6cqG1LlmWmTZtGQEBAuQw2G1Sshb2dLTVDexv8XBdXB50s55ZxyjzQJeuV97FZxzEkblV2xunQ7c2id1YocQ7uVQ06P6jlcyQkiGlJguFyfpdUc/LmXnoqduZKhtM7KwtPywwA7mWoscoV0FW0NCPUzQWAl59/H4AHUTGAiUYHJAk5nwxneSUCzseQJBskxynI1p2Q49/NznYORbYdhuQwCUnSr3bW0yItI4vQicuK9Rr7F4/FxurJRa1zB6VbtmxhzJgxVKhQgVq1arF792769evH1atXuXnzJpGRkQBERETg6fnfYpeKFSty/fp1nXZHjBjB2LFjtaUmBEEQBKFQxJC6DhFw6kGybABuvyEnzoPUdcqK9owD4Pwpkrm/qbtXrm3dupWUlBQmTFDmC27bto0FCxZw9OhR3NzcaNGihUFDF1WqVGH69Om0atUKHx+fYuq1IAiC8NQrYlmkp40IOPUkqWyRnGYgW7VGTpgKWZeQY/qB0xwk686m7l6JsLY0Z//iscV+DX1t3bqVTZs2sXr1am3Gs1q1atq5nQDff/89QUFBAPj4+HDv3j3tY/fv3yc0NFSnzRkzZrB+/Xpat27Nrl278PPzK8rLKXMCmnV/7C/CJ5UUyjmee0HOkI5vax8vDUPppXWhUO731lhF5o2ttPVHeHrlfNZcnhlIbeCfP5QpOnGZaXz88jsALFw7DQuViso2NgB42zhTo9FgbRtxsYmYmVuWbMdzU6mUW+775Vj5fvWFIFm3Q3L7HSybgpyM/HA8moS5yHLxzm0sDSRJwsbKolhv+u7ytHHjRnbu3MmKFSswMzPTZjinTp1KUlISAMePH8fS0pLWrZWdcgYPHszWrVsBSEpK4uDBgwwcODBP2zNnzmTo0KG0bt2ay5cvG+OtEwRBEMoZWcp7K89EhrMQJLMK4LIaOWkRJH8DKauQs66Ayxflbl6nKZw+fZpBgwZRoUIFNmzYAEB8fDyffab8Bfzcc88REBDAw4cP+fnnn7XPmzBhAqNHj2b48OFER0ezcOFCvLy8yMrK0i4cmj17NnPnzmXGjBmYmZnRpk0bhg4dql1sVN7lzmDmvl/QeY8752mTe8FUDn1ee87zbpz8CYCv7oajlpXSLgPr9cS3XrMi9ack3/+yWGpKKBvqNn0F0P08v/nCTJ1z8vv8mfTzWMCQenlV7gPOXyPDqF+/vsH7p0uSOZLDZGSLYOT4yZCxDznudRF0loB69eqRlZV/RvlxgaGVlRWrVq3Kc9zc3Jxly5axbJnugqjp06eXy5XqgiAIghGIRUM6yn3A+UtkGHbnPXkrqAfmKjODny9ZdwLJGfnhayLoFMqNwmQNjJ39yp1RLIksxvl9PwJQq1X/J55rSH+S4u4CcCbuNgD/xiZxPlHJcLpZbmdkITOcOUoy0ymym0JhHflT2e+7cYdR+T6uz2erVGU3AfmRskhyOV80VO7ncEpI/BIZxrBDX3I+/lbh2rBqiuT8FUg2StAZPw1Zlp/8REEQBEEQnkqySspzK8/KfYZzXEAnflRd5FLCHV45+CX9qjVjVI2O2JkblqGUrJqC8xfIccMhbRNYNgLbAcXUa0EoffTJYJbW1df6eFJms7BZ33vXdgFgY6aMsNSytyJTTgOgdeUQg9ssSn8EwVQSMlNM3QXjE3M4dZT7DGfjCv782OoNOnuFoEFmw42DDNj3KbvvnTU4SylZhSLZTwJATvgYOfNccXRZEARBEITSTuK/oFOSlPvlWKnKcJ49e5bZs2fToEEDrly5QpMmTRg+fDjh4eHMmTMHPz8/oqKiWLBgAebm5kRFRTF16lT8/Py4ceMGCxYswN7e3uDrulk58FFwf7pVrs+885u4lRLLOyfXEuxcjXGBnannUk3/xuxGQOYxSN+N/PAtqLAJSTJhHTBBKCFPyqgVV8atLGfyXFwdSMxMBaBv7ykA1D/5L5nJDwCeuMXorm2f0q7rG8XaR8F49vyxmDZdJpq6GybxpM9q+66TSrA3JaOgOZzlddFQqcpwRkdH8+qrr/LWW2+xbNky3n77beLi4hg1ahTjx49n6tSpWFpasmbNGkCpudijRw+mTJlCvXr1mD9/fpGu37RCDdaGTuAVv7ZYqSw49fAGIw6v4O3jPxCRFKVXG5KkQnKaBypXUF+F5NVF6pMgCIIgCGWPjKQNOmVJQua/RUPnz58vV8EmlLKAs23btrRt21Z738LCApVKxYEDBwgODgagWbNmbNu2DYDt27fTpEmTPMfzk56eTkJCgvaWUxz8UdZmFoyq0YGfn5lEryqNUCGxN+o8A//9jNlnfyU6LeGJr0NSOSM5KDshyEmfI6tv6/cGCHqbMGECr7zyCpMmTaJ9+/b8+uuvADx8+JCBAwfy2muv0b17d/bu3at9TkZGBiNGjGDEiBH06tWLjRs3ApCVlcWoUaOQJIkBAwZw8+ZNrl+/Tp06dejUqRN//PGHSV6jIAiCUHbpBJuPZDvLo1I1pJ7bl19+ydSpU0lJScHW1lZ73NHRkejoaEDJiDo4OOQ5np85c+YwY8YMva/vYe3Ee3WeY5BPKF9c3sk/URf47dYRtt89yYs+LRlc/ZnHLyyy7g0pP0NmGHLCbCSXz/W+tvBklpaW2pqau3btol+/fvTp04f33nuP+vXr884773D79m0aN27MtWvXsLa25rPPPsPCwoIvv/ySpKQkAgMDadWqFZ6enixfvpwVK1bw/vvvU7VqVVasWEH//v1FHU4DRN+Lxt3THYDrZ49SvU4jvZ5X2PJGZXkoPbdHhxn9QloW6rmlseh6XGwiCQl5C+KXV+V1OB3A1pRbTBpoxY8fYm+uhEcvPjet8A1J6M7bLN/xZunKcOb4+eefSUxMZMKECbi5uZGS8t/qtYSEBNzdlf/U3N3dSUxMzHM8P1OmTCE+Pl57y535ehxf+4osaDCEr5q+Rl3nqqSpM1l5dTfP/7OQn28eJkujzvd5kiQhOX4AmEH6n8jph/R89YI+ck+fuHz5sjYD/sMPP9CtWzcAKleuTKVKldi+fTsAa9as0T5mb29P8+bNWb9+vU67siwzbdo0bGxsRLApCIIgFJrIcOoqdQHn2rVriYiI4L333uPUqVNERETQokULTp06BcChQ4fo2rUrAJ07dyYsLCzP8fxYWVnh6OiovRm6uCjExYdvmo5kbsgLeNu6EZuRxLzzmxi0/zP23j+f74p2yaIG2A4CQE6chSznH5yWFbIsk5qVUaw3QyoDnDhxgueff55Vq1axZs0aYmNjSUhIwNPTU3tOxYoVuX79OgAREREFPpZjxIgRBAYG8tJLLxXx3Sqbou8VPErwJDnZTYDqdRpx9eS/XD35rzG6JRQgv+00S5OoS3t5EL7f1N0oUT/+NptDOz/n0M7SN6r1zx+fGb1NfT+DzTqWjfmKX/04g2vJKZhJEmZFDBBFwKmrVA2p7969m9GjR1O/fn22bNnCgwcPWLZsGcuXL2fWrFn4+vqSnp7OkCFDAGUbwylTpnD69GkiIyNZtGhRsfZPkiTaedahlUdNfokMY2X4Lm4kP+DtEz8Q7FKNcQF5V7RL9uOQU7dA1iVI3Qi2A4u1j8UpTZ1J678+LNZr7H32Q2z0HHqpX78+P//8M3/++SetWrVi3759Rb5+lSpVmD59Oq1atcLHx6fI7QmCIAjl06PF3nO+Lq+r1EtVwNm2bVvi4+PzfWz16ryrvT08PFi5cmVxdysPC5U5A6q1oFulBnx/fS/rIvZzKk5Z0d7aoxavB3Skur0HAJLKBezHKhnOpKVg3RNJZfuEKwiPo1arSU1N1WapO3ToQGJiIuHh4Tg4OHDv3j0qVKgAwP3797WBo4+PD/fu3dO2c//+fUJDQ3XanjFjBuvXr6d169bs2rULPz+/knlRpUTuLGVRuVZVpjmU5WLvpV3u97Q0vr9mlraoMsrXrmu2ZuZEpeW/KNXUnukyodDPfVwm82n6GX+t/wes/3UWLYOLvnGL2NpSV6kKOMsaewtrXg/oRN+qzfg6/G+23DrG3qjz7Iu6QI8qDXnVvz0e1k7KsHrK96COhJRvwf51U3e9UKzNLNj77IfFfo0niYyMZOrUqaxduxaAO3fukJiYiI+PD4MHD2br1q3UqVOH27dvc/v2bbp06QKgfax79+4kJSVx8OBBli5dmqf9mTNnYmZmpg06AwICjPsiBUEQhKefWDSkQwScRpCzov0Fn5Z8cXkne6POs+nWUbbfOclz3k15sXpL3O3fQI6fhJz8NdgORFK5mrrbBpMkSe/h7uLk6uqKWq1m2LBhuLi4cP78eVavXk21atWYNWsWI0eO5LXXXuP27dv873//w9raGlBKKY0ePZrhw4cTHR3NwoUL8fLyIisri4kTJwLKNI25c+cyY8YMzMzMaNOmDUOHDmX27NkmfMVlk77ZjqchKyLkz79hOxISnlxKrizImY/8pCoC3XtMLonumFRyvDLXO/neeTTqDDxrdQDyVpwojZUT9DGwz3tGaaegDGd5JQJOI6pu78H8BoM5HXeDpZe2c+rhDdbd2M/Gm4foVjmYNz1qYKm5AqmbwG6YqbtbZjk6OrJhw4Z8H3NxceHHH3/M9zErKyttKaXczM3NWbZsGcuWLdM5Pn36dLFSXRAEQSgUjUqCXHM4NSoRcApGVs+lGl81fY1DD67w3bW9HI+7zqZbxzFPdeBtb0hL2oC17VCkcv7XjiAYy8ldyhxvJ4+6OFcKBAzLnP7422yOxT0EYN6wTwDD6lreun6NKtV9C3y8sLVG9bFv+xIA1LKm2Oo8Fmf/ywpD6qM+zX7f/Rm/ZVezsMkOoGpHHANgVNd3dc69cvQHdkffAuCdF2eVYC9LB1lSbrnvl2elrizS00KSJJq7B7C86at83XQkoe6B7HxYhQyNCiv5GgvPfMKJ2OsGlQESBEEQBKGMkKS8t3JMZDhLQLBLNT5t+DKXE+5yKeYadW3O4sU/jAyLJ8ixMoN8QnnWsy7mKjNTd1UQBEEQBCMQGU5dIuAsQQGOXsiWryM/fJ1ublGsuGfGhYTbTD/9I8subadfteb08W6Co4WNqbsqCI9VmoZYv9k4gytJyQCkXjvHe13ezH5E/3717z2VKbPHA3B5mVI65tex+hfJftxwOhTve+ThpFw7PS222K6Rw9Tfa8E04mITSYxRhsbnhkdx6Xb2A2Yy1jYSf1srZaCc/1zAwA5vaZ9jb+OGm2WUKbpcKhS0aEjU4SynklLTS/aCVq1AssPRLJ7fW3Zh4500Nt48RFR6Ap9f3sHKq7voUbkhA6q1oKpdhZLtmyAIgiAIRiGrQKPSvQ+iDme59ebyzQyJyqJb0yD8KhV/gCdJVshW7SBtC/ZZexnuP4Uhvs+w8+5p1kb8S3jiPTbePMRPNw/TyqMmL/u2pq5z1WLvlyDkp6CFMyWR6Qo/8Q8AmvQkApoVvG3tjZQUtkWnAXA3WSJg35cAjB34kd7XWvPzTO1i0qjsQuXn/llP7WdK/85ggc27F/s1RGaz/Mk9iqHRqFl18DsALkfIOMZnAuAQn0qmlQVRVZXNTD4JjyPA4WsAGjR7Fa/aXWjv8vjsv6mURMkm+ZF5m6IsUjmXmJrBtzuP8u3Oo9T09qBb0yA6Nw7EzdGu2K4pWXdCTtsC6buAKViqzOleuQHdKtXnaOw11kb8y/7oS/wTdYF/oi7QwKU6L/u2plmFGmJluyAIgiCUATLoFHsv70uEy33AObFPKy4nqvj3zHUuRkZxMTKKxb/8Q7OganRvWovWwX5YWxr5bbJsAViA+gZyVgSSuQ+grGxv7OZHYzc/IpKiWHN9H3/cOcnxuOscP3adQMdKvFT9Gdp51sFMKt8FBiZMmEBiYiLOzs6cOnWKsWPH0qdPH2RZZtWqVbz77rusXr2a7t3/y/5kZGTw+uvKLk/R0dEMHjyYfv36kZWVxdixY1mxYgX9+/dn/vz5qNVqevToQeXKlZk4caJ2t6LyxpSZrYSYSwA0ePbVfB+/8O8vADxTwYO7acqkshhbNcHOho9UdG87ATNJKS/kaKHsdlWpTrd8z426G0V6chwAGUlKeRhjl8wpTXNkBSEzLZlDD1MAMM/U4PRAmbNpERePpY0V7tlB1R1LO5ZcuwFAj+RFdGowiOp1Gpmkz0+S++eq0YLxHH1ridGvITKcusp9wNkkqCqjGjQgLimVnUcvsfXwBc5G3GP/uQj2n4vAztqS9vVr0K1pEA1rVEFlhMKtksoe2bIhZByC9H8gO+DMzcfeg/frPs9r/u1ZG7Gf324d4VLCHd47tR7vK24Mqf4MXSvXx1JVPr+FlpaW2iLuu3btol+/fvTp04f169fj6emJnV3eDPVnn32GhYUFX375JUlJSQQGBtKqVSs8PT1Zvnw5K1as4P3336dq1ara4FMUfhcEQRAKQ35ka0uxSl0AwMXehgFtQhjQJoQb9+PYevgC28IucCcmgc0Hz7H54Dlc7G0Ire1Dy7rVaR5UDQdb60JfT7JqjZxxCDl9L5LdSwWeV9HGmTeCujHMry0bbx5kw40DRKbEMPvcr6y+toe3g3rQ0qNmofthCFmWQU4t3otINnpNG5g/f77268uXLxMcHAzAoEGDAPJd+bdmzRrtFpX29vY0b96c9evXa7e1BOU1Tps2jYCAgHIdbOZk2HJnAUp6m7oqtXs99vGgls8B4BmbSGFyKLlfj4urA13ajNd5vKDX6uHlwaGdGwF4kK6sjk+Ou0a9tgX/HJfVLf7Ku7jYRNRZUrn/3v26/yuOxii/l7MsVNogSraxIs3ZgYcuVgAEucu4mCvl/dLUau5d24W9ixdQujP1r1V1K5Z2NZKk8/+ZyHAaKCoqiuPHj3Pv3j00Gg0VK1YkJCSEypUrF0f/TKJaRRde79mCUd2bc/LqbbaGXeDPY1eIS0rl98MX+P3wBcxUEiF+lWlZpzqt6lanuqerYfMrLZsr/2YeR5bVSNLja3A6W9ryqn97Bvu0YtOtI/xwfR93U+OYdPx72laszaSg7lS0dirCq9aDnIocFVKsl5A8ToJkq9e5J06cYObMmURGRvLrr78+8fyIiAg8PT219ytWrMj169d1zhkxYgRjx45lyJAhBvVbEARBEHITGU5degec4eHhjBkzhl27dmFlZYWDgwMqlYqEhARSU1Np2bIlS5YsoV69esXZ3xKlUkk0qFGFBjWq8O7AdpwMv8O/Z6+z7+x1Iu7FcuzKLY5ducVnv+6jkpujEnzWqU6jQG+sLJ7w1poHKIGVnAxZV8EiQK8+2ZhbMtAnlJ5VGvHN1V2si9jP7vvnOPzgCq/VeJb+VZuXmwLy9evX5+eff+bPP/+kVatWnDlzJt+hdENUqVKF6dOn06pVK3x8fIzT0TLkz+2fkWIm4ZQ9j7FVy9e1j5V0hsLDy0Ov8wrbr0efZ0g7zToqGfRd2z7VHssvK1xYhrRRkvM9y1um1sXVAUfHp//1tls8HjsziS3j/qs9m/N9jotN5H56uraKg2wlcbeqMwA2KVkkullSo5Ly2LxaVfGv3AyAG3eO4N/wxTLxeXmt/wfF0q4IOHXpFXAePXqUMWPGMH78eL799lu8vLx0Hn/w4AG7d+/m9ddfZ8aMGbRv375YOmtKFmZmNA70pnGgN288/wy3oh9qg8+jl29xJyaBH/ee4se9p7C2MKdxTW9a1alOi9rVqeSWt96WJJkjW9RT5nFmntA74Mxha27F+MAudKkUwrxzmzj98CaLL25j6+0TTKndmzrO3sZ66bk6baNkIIuT9OSi92q1mtTUVOzt7QHo0KEDiYmJHD16lNatWxf4PB8fH+7du6e9f//+fUJDQ3XOmTFjBuvXr6d169bs2rULPz+/Qr4QQRAEoTwTi4Z06RVwHj58mF27dhWYPapQoQL9+vWjd+/efP75509lwPmoKu7ODGxbn4Ft65OanknYxZvsO3udf89eJ+phEvvOXGffGWW4tpqHC02DqtI8qBoNA6pgb6PMd8EiGDIOIWeeQmJAofpRw8GLr5q+xuZbx1h2eTtXEu/y6uEVzK8/2OhzOyVJ0nu4uzhFRkYydepU1q5dC8CdO3dITEx8YkZy8ODBbN26le7du5OUlMTBgwdZunRpnvNmzpyJmZmZNugMCDDsj4GyrEPnCazbvojodGVDhMrH1nEs7i4Am+7F4m6pVEf4tL9S47IsZC+KU7uub+h13qPvk7GyoeEn/uHgNaVeqYe1NU2ajzRKu49qvlCZ3/qMqzXzhn1i1LYF01NJ6GQ3H/Va69G4WymLNHdGP+R8ovJ7oKa9FUO8K9LhmXF5nuNaNbh4OluGaFQg5VP4vbzSK+DUZ+ulqKgoPDw8dBZglBc2Vha0DvajdbAfsixz+VY0+85eZ//Z65y5fo8bUXHciIrjx72nMFNJ1K3uRbOganSo40U1KyDrcpGur5JU9PZuzDMeQcw59xt7o84z5eQ6Pm/8CvVcqhnnRZYirq6uqNVqhg0bhouLC+fPn2f16tVUq1aNCxcu8PnnnxMbG8vy5cu5desWo0aNApRSSqNHj2b48OFER0ezcOFCvLy8yMrK0n5uZ8+ezdy5c5kxYwZmZma0adOGoUOHahcbCYIgCIJeHhlSz/labG1poJiYGJKTk7X3Bw4cyIEDB4zSqbJMkiQCvT0I9PZgRJemJKakceTyLQ5fuMHBCze4FR3Pyat3OHn1DjsOxbJxDKSlXmLbPydpGuSDt7tzoa/tamXPnJBBvHV8DQceXOaNY9/xVdPX8HPwfPKTyxBHR0c2bNiQ72NBQUEsW7aMZcuW5XnMyspKW0opN3Nz83yfM3369HK9Ul0QBEEovIKG1MXWlno6duwY/fv3JyIiQimTk03sgJM/B1tr2oX40y7EH4DbD+I5dOEGhy7c4NjlCLLUKqzN01m5dTOz1zlQ2c2RZrWq0axmNRoFeuNkZ1jpJXOVGXNCXmDs0VWceXiT8Ue/5eumI6lk61IcL094CrlZWjGy/xQAjv35FXGZGQDcTZdRSRoA4m5fyD47KN/h2/K2uMRQRX1vLh38HYDrMRdYfiMKABszmG/9IwCRKovHlmkyxKK172OX/T9FqlpjlDaF0mW0j1eBj+V8Vl/o8BYAXe9c4vKNPQD4Vgyhgm/TfM8XxKKhRxkccL777rv89ddfvPLKK+zevZvMzEy2bt3KyZMni6F7T5/KFZx4vlU9nm9VD7VGQ/q9LZgTQYcQM9b/q+J2TAI/7zvDz/vOIEkQWMWDRgFVaBzoTX3/yv/N/3wMG3NLFjV4iZFhX3EtKYpPzm9icaOhxf/iBEEQBEFQFDCkXl4ZHHBKkkT16tXRaJS/dC0sLOjduzcrV640eudKwsop/yNzvEzDjsGYP6mUkZGZqVRYW1eGjAje6F2LkX26ceyKMvx+6MJNrt+L1W63+cPfxzFTSQRVrUjjQG+aBHpTz68SNpYW+bbtZGnL9Lp9GXrwC848vIksyyILLeilb+8p2q99Gw7ihexFQ9VOb8TGTPkZcfJ6/EKqspjl0HchT2nI3l59oGSYdz+IJjxR+bl2tZKJz1BeQ3DT4Ua71qQXPmZS9te5SzAJT4/6vo9f6Jv88D42jsqWsc6VAmlSKbAkulXmySpALBrSMjjCysrKQqPRYGVlxd9//0379u05duwY586dK47+FbujO09x+c+bOLs70mZgKB1eak2NBr4lF5ypsudxaBKxs7Pkmbq+PFPXF4Do+CSOXb7FkcuRHLkUya3oeM5G3ONsxD1W7ziChbkZdat70jjAm0aB3tT18cQyV9DsZ18RM0lFYlYaD9ITcbcuf3NGBEEQBMEkHpnDSTlP+hgccHbp0oUvvviCN998k27duqFSqUhPT2fu3LnF0b9i13ZgKFd33eJhdAK/Lf2D35b+QdWgyjw7uDVtB4Xi6aNf8elCk7J3B5Lj8zzk7mRP58Y16dxYKW90NzaBo5eU4PPI5UjuxyVx/Mptjl+5zYqth7C2MCfEvxKNApR6obWqVaSKrSs3kh9wNem+CDgFg7m4OmizeZ1cxuscL60WrX0fUDJzhtD3NRnjtRe1WHvXHm8DcPC7d2iRvSuft7UlAbX6FLlvj1Oav+9C4fnWbfLYx6v4+nPzipJVd3Crkudx8bkQ9GFwwPn2229rv75w4QLHjh0jICCgzO4w1P/tXtT7vh7Hdp7irx/+4cCmI9y8cJtV761l1Xtr8antTZMu9WncpT61QwOxKGAIu9CyM5yyJuGJ0zu8XB3p0bw2PZrXRpZlIqPjOXLpJkcuRXL08i1iE1M4dOEmhy7cBMDR1gq7UBls4eyDWzSrUMO4fRcEQRAEIV9i0ZAuvQLO+Ph4JkyYwNatW7GwsGDgwIHMmzeP6tWrU7169eLuY7EztzCnabeGNO3WkOT4ZPb9fJi///cPp/eeJ+JcJBHnIvlxwWZsHWyo/2xdmnRpQJMuIVSo7Fbka0uSPTIoW1wa9DyJqh7OVPVw5vlW9ZBlmWt3Y7Kzn7c4eimShJR0kqKTUVWDL7cdYNcvd2heqxqhtX2o6+uFhVn52AJTMI6yksUwNLNZnMKP7QLAxq06lX3++11prPeyuWsFPn757SefKAhFVLVGkPbrktxO1VBf/TgDKL7tKg0ioTOHUywa0sP48eOJiIhg+vTpZGZm8t133zFr1iw+/PDDYu5eybNzsqPzK+3o/Eo7EmITOf7nacK2n+DIHyd5GBXP/l/D2P9rGAC+9arRpEt9mnRtQK3mAZiZFyKAy9m5x8CAM08zkoRfpQr4VarAwLb1yVJrOBtxl3kXN3GVWyCjXYC0escR7K0taRpUlRa1fGhR24eKLqXrl4YgCIIglGlilboOvQLOkydPcuzYMczNldOHDh1K9+7dn8qAMzdHVwfaDAilzYBQNBoNV45f58gfJwj74zgXD4dz7fQNrp2+wfp5v2HnZEvDjsHK8HvnEFw99ax7KWVvFyqnGLXv5mYqQvwqUyOpAlfv3mJ0txZ4xlfk4LkbHDwfwcPkNP4+Ec7fJ8IB8K/kRovaPrSo5UN9/8pYFCZ4Fp4K92/fpWLlguvyFSdDtnwsapalJFabqzOUn+uUB1fBx/ijQTlzOQUhP1eO/kWNRs8apa3cP5s5PzdxsYmlompDbqUis5nt0TVDIuDUg4uLizbYBGVrQSsr3XqQS5cuZdy4vPupPi1UKhWBjfwIbOTH4Pf7Ev8ggWM7TxH2xwmObD9JQkwi/2w8yD8bDwLgU9ub2qE1qdsqiDota1Kxmnv+DUs2yr8a4wacOdSyGgAHGyu616xF96a1UGs0XLgZxf6z1zlw/gZnI+4SfieG8DsxfP/nMeysLWkb7EfXpkE0DvTGTFXOazkIgiAIgqEkHlmlbrKelAp6BZwpKSmcOXNGZ2eh5ORknWNr1qx5qgPORzlVcKTdC61o90Ir1Go1l49eI2zbccL+OMHlo1e1cz+3fvUnAO7ebtRpWZM6oUHUbVWTarW9UalUIOUE7unF0s+kLKVdW7P//kAwU6mo4+NJHR9PRnZvzsOkVA5fuMmB8xEcOB9BTEIKvx++wO+HL1DB0ZaOjQLp2iSIoKoeopanIAiCIOhDDKnr0CvgPHr0KCEhIToBJ0BwcDCSJJX7ouJmZmYENa1BUNMavDxjAA+j4zm3/xJn9l3g3P6LXDl+nejIGHav28/udfsBsHe2o1aLADoMkHimA8gadbH0LTotAeCxJZGc7W3o1DiQTo0D0WhkTl+/wx9hF/nz2GUeJKSwdtcJ1u46gU9FF7o0qUmXxjWpUoQ934XSzVTD6VC4ofHSNJyXI2f40SOwNVC6+wils39C0RlrOB3QGUbP77iQl6RSblrlfLBQr4CzadOmrF+/vsDHZVlm0KBBRutUWefs7kRo7yaE9lZqm6Ump3Hx8BXO/nuRs/9e4PzByyQ9TCZs2wnUyQk80wGunb7GFzPep05oTeq0CqJ2i0Dsne2K3JeodKW+p7uVfr8UVCqJEL/KhPhV5q1+bThwPoI/wi6y9/RVIu7H8eWWg3y55SD1fL3o2iSIDg0DcLG3KXI/BUEQBOFp8miCs7zTK+BcsmQJ1apVe+I5Qv5s7Kyp364u9dvVBUCdpebqqQjO7rtI8oM/getIkpwdkF6Eeb8hSRI+dbypE1qToOYB1G4RiJdvRYMyyWnqTBIyUwFwt3YyuN8W5ma0rudH63p+JKWms/tkONvCLnLkUiSnr93l9LW7LPhxD81rV2PIsw1pFOBt8DWEp4shi37Cdn4JKPOMm3caa/C1TJVZKW2LJAShJInPvgHEkLoOvQLOxo0bP/Gc3bt363WeAGbmZgQ09COgoR9yhjty7Da8Az14c+XrnN13gbP7L3L7yl2un7nJ9TM32bJ8JwDOHk7Uah5AUDMlAA1o5IuVjVWB14nPUEotmUtmOJhbF6nP9jZW2qLz0fFJ7Dh6mW2HL3AxMop9Z66z78x1GgVUYWS35jQMyLsThSAIgiCUJ0VdpX7t2jXefPNNrKystKPM4eHhzJkzBz8/P6KioliwYAHm5uZERUUxdepU/Pz8uHHjBgsWLMDe3t54L8YIDN5pKDY2lpUrV3L16lUyMjK0x7dv387kyZON0qno6GhCQkJ4//33GTVqVJl+g59IUvprYZFG52Ft6TysLQBx9x9y9t+LnDtwifMHLxF+/DoPo+I5sOkIBzYdAZTA1b++D0HNAqjVPJDaLQJw966gzYJmyRoAzFUqo86xdXeyZ3D7Bgxu34Brd2PYsOcUvx04y9HLtzh6eSONArwZ2b0ZDWuIwLM8uXL0L1adVf44mjP0kyee36TjaADtlnllxZMyPHGxiTy4dhgA+4rKtrSUwqxQ7tdx65pSHq2Kr79Rr3HtTBiJSUlGbVN4+n30/RSmvzSnWK/x59aFXEhUppyNH/hRsVxD9cgcTtnAOZyHDx+mc+fO7N69W3ts1KhRLFy4kODgYCZPnsyaNWsYNmwYU6dOpUePHvTq1YsvvviC+fPnM2PGDCO9EuMweArrc889x549e3B1daVatWra26NlkgpLlmWmTZtGo0aNtMdGjRrF+PHjmTp1KpaWlqxZswZA+wZPmTKFevXqMX/+fKP0oURlB5zIj0zEruhMq+ebMWrhyyw5MJvfHn7H4n9n8tr8l2j5XFNcvVxQZ6m5dOQqvy39g9kvLOZFn9cZ5D2Sj/ov5KdFW7hy4hoAqmLM4/t6uTFlUDs2zRhGv2eCsTA34+jlSF5dtJGRi3/i+JVbxXZtQRAEQSitcjKcuW8ACQkJOrf09Pyr1AwaNEgntsrIyODAgQMEBwcD0KxZM7Zt2wYoSb8mTZrkOV4UO3fuLHIbuRmc4UxLS2PPnj15jgcFBeU9uRA+/fRThgwZwjfffAPk/wavW7eOYcOGsX37dj7++GPt8ZEjRxYY0aenp+t8U5NKy1/dquwsg5yKLGciSfnv1W5pbUntFoHUbhEI9ECWZaJuPuDcgUtcOHiZcwcvcfVkBDF34tj30yH2/XQIdWUL+NqH9OQMVrz1vTIc3zyACpVcjf4yPF0dmDKoHcM6NWbV9jB+O3BW2WbzUiRNAr0Z1aM5IX6VjX5dwfRy5m2eunWEf+PSAHjtq0l89doivZ6fe8u8kmbInFN9KW011bvd0rDq1865otHbjAy/xO3bh0hOTjN628LTrbizmwAdur1Jh2K+RkFD6t7euusdPvjgA7020omJicHW1lZ739HRkejoaEAZGXZwcMhzvCiGDx/O/Pnz6dOnj1GSigYHnA0aNCAuLg4XF92ddO7cuVPkzhw+fJj09HRatmypDTiN9QbPmTOn1KWXAZBy/eciJ4Gk3w5FkiRRsZo7Fau5025QS0BZDX/56FUuHLzM+UOXORURThKgyVTz06It2ue6V3GjZlN/ajapQVCzAGo09MXa1jgZak9XB6a+0J5hnZXAc9OBc4RdiiTsUiRje4XySucmRrmOIAiCIJRmBQWckZGRODr+V6pQ32DOzc2NlJT/NolJSEjA3V3ZVMbd3Z3ExETs7e11jhdF5cqVSU1NpW/fvlStWpWhQ4cWaa2OXgHnK6+8ov06LS2N2rVr07x5c5yc/lv5vH37diZOnFjojgBs2rQJe3t75s6dy5kzZ4iPj8fW1tYob/CUKVOYNGmS9v7Jkydp3bp1kfprDJJkjow5kAVy0Yq/29hZE9y6NsGtawNwMPoyE459SwUbRzqO7MD5g5eJOHuT6FsxRN+KYd/PyjwzlZmK6nWrUrNJDWo2rUFQU3+8a1ZWCtMXkperI++98CzDOjXhq62H2HzwHMs27ScpNZ1xvVuW67qtT6u+vafQN9d9fbOHxbXq25SrycvaSt7i6K+3fyBZ6UliDqdQbqkeCTjl7K8dHR11Ak59WVpa0qJFC06dOkVwcDCHDh2ia9euAHTu3JmwsDB69eqlc7wo/v77b+zs7Bg2bBiXL19m1apVTJ48me7duzNkyBA8PDwMak+vgHP37t0MHTpUez8wMDDPOcZIt86ePVv79cWLF2nWrBkvvfQS33//fZHfYCsrK50+lq7FRTkBZ5ZRW72Z8gCAWpWqMeHLwQCkJqVy+dg1Lhy6wsWwK1w8fIWYO3FcPRnB1ZMR2p2RbB1tCGzsT1BTJQit2bQGLh6Gl1aq5ObIhy91xNfLlcW/7OPbnUdJTsvgnQHtUKlE0CkIgiA8ncwKCDgbN26MmZkZY8aMYcyYMQU+f+vWrWzZsoUrV66wZMkSxo8fz/Lly5k1axa+vr6kp6czZMgQQImfpkyZwunTp4mMjGTRIv2mND3O2bNnadq0KRqNhkuXLnHp0iUOHDiARqMhLCwMgPfee4969erp1Z5eAecbb7zB+PHjH3vOo3MSiuLbb7/l9OnTxMXFUaNGjRJ9g01CMgcZwMgBZ7IScFazq6A9ZmNvo5MFBYi+FcPFw0rweSHsCleOXiMlIZUTf5/hxN9ntOd5+rgrwWd2JrRGg+pYWlvq1ZeXOjTCztqS2ev+ZuM/p0lJz+SDIR0xNyvnWy8IgiAIT6WChtSPHDmiV4azW7dudOvWTeeYv78/q1evznOuh4cHK1euLEp383j11Vfp3Lkza9aswcLCgiFDhjB//nz8/ZVqFvfu3aN3794cOnRIr/b0CjhHjBjxxHNyht1TUlJ05lwWxtChQ3UyqkCJvcGmkfNtMG7AeUMbcD5+Lod7FTfcq7jR6vlmgFKY/vrZm1w8HK4EomFXuHnhNvciorkXEc2eDQeUXluY4RvsQ61mAdRppewR7+pZ8BzU51vVw87akve/3c7WwxdITc/kk1e7i0xnGabPsHVBWyjmHH90y9ySZMhQcnFtBVkcw9lrf5nFC8+9p/f5xbF4CqB67YYkJCQYtU2heOzfvhQHK2UUy87VH7/gFibuUdknScqweg5NGfuv7tKlSwQFBbF69Wo6duyYZ5pdeHg4UVFRerenV8A5Y8YMWrVqRffu3R973t69e1m/fj1ffvml3h0Q+C/DKRt3P/W7qXEAVLY1bFW6mbkZ/iHV8Q+pTveRyjq+5PhkLh29xoVDl7OH4sN5GBXP5aNXuXz0Kr8t+0O5Vg0v6rasSd1nalG3VRCe1T105mt2blwTGysL3vl6K7tOhnPsyi0aB4odigRBEISni4RuhjPnS32H1E1t8uTJ2kpA+fH09GTjxo16t6dXwPnhhx8yZMgQZs+eTdu2bfHz88PR0RFJkkhMTCQiIoK9e/diaWnJhg0b9L64kEOT/a9xh5dT1Ephfvsi7jIEYOdkR4P2dWnQXtmeU5Zl7t+I5uLhK5zbf4nT+85z/fRNbl+5y+0rd9m+WilU61bJRQk+WyoZ0Gq1vWldz49OjQPZcvA8e09fFQFnGXT1lJLltrT/b7rGo9mxnPuPlv15VHEtIHtSts7QbJ6+r6c0MCS7CXlfmz7vzUffTwFKpoSNUHg7ti4AoFO3tx57XmjncVwJU+ouiuymcageyXAaOqRuagUFm+3atWPXrl3aoXV96RVw2tjY8NNPP7F582bWr1/Pjz/+yP3799FoNFSsWJGQkBBGjx5Nv379xOrjwsjeEQgjv3epWcqqd1tz/eZZGkKSJDx9PPD08aDNgFAAkh4mc27/Rc7su8CZfy9y+Ug4MXfi2LN+P3vW7wfAwcWO2i1rYlW/KgB7Tl3lzb6txedGEARBeKqYl/Eh9WvXrvHqq68SFhamUy2osAyqw9mzZ0969uxZ5IsKj8rJcJoZr0VZQ6o6EwAbM+MHnPmxd7ajabeGNO3WEIC0lHQuhYUrAei+85w/eJnEuGQObTmG/McJeLkJd2ISeL3bTFo0rUmdVjUJahZgtJqggnFcOvg7AJqsNDxrdwIMy4AUlC0rbaWDHs3ufbNxBiP6fWDKLpU4Q74nt9KUP2h7LZvA/MZdAAho2rlY+iUU3t1UJVDQZ15vjSYdS6JL5caji4bKWl5l3LhxTJs2jalTp7J+/XoyMjLYunVroeuuG1z4XSgOxh9ST1dnIStL37E1M00AZ21rRXCb2gS3UVbEZ2VmcfVkBKf/ucDZfy/wV3QSqV6OnLkXQ/iMHwFlIVJIuzqE9m5Ki16NHrsISRAEQRBKq4KG1MvKHM6MjAzatm2LlZUV1apVA2DixIk899xzhWpPBJylQs4qXeP9+ROboRRbtlSZY22W/3aZJc3cwpzAxv4ENvan35s90GSvVm/csxEetapz5p8LRN+K4eiOUxzdcYolr39NUPMAWvZuQovejans72Xql1AuBTZ//GLBp01OprOha5V8Hy9tmdn8XDn6F5mpsQDUatVfe9yYq9FfrlpdaTMzFfcaoUVuTygeQ/tON3UXyq2yPodTo1GSYZIkcf78eWrVqsXt27c5depUodoTAedT6n7aQwAqWjuV2vmRp64pafm+/VoSWtsHWZaJvHSHA7+Fsf+3MC6GhXP+wCXOH7jEV5PX4FPHm9DeTWjZpyl+IT6l9nUJgiAIQlmfwxkSEsLixYt59dVXadiwIdWrV+fGjRu89tprhWpPBJxPqftp8YAScJZG0fFJ3IqOR5Kgnq+SuZQkiao1K1P13T4MfLcP0bdiOLDpCAc2hXFqz3kizkYScTaS/838mYrV3GnRqzGhfZpQp2VNzMyMN/9VMI4VP34IwMj+H5q0H4XlU7//k08qZXIymCpza7xqd8nzuDGzs6GdxxmtLUF4Gj1ah1MuYwHnwoULtV97e3tz+PBhAgMD6dGjR6HaK3TAeeLECaKjo2nXrh1JSUk4OzsXtimhGNxLVQJOTxtn03akAKeuKtnNGpXdcbDJf46pexU3eo3pTK8xnUmMS+LQ78fY/1sYR7ef5P6NaH5dso1fl2zDqYIDzbo3ouVzTWncJUQEn4IgCILJmUnKTauMzeHMrVWrVrRq1QqAjRs30q9fP4PbMDjgjIiIoHfv3pw9e5bq1atz7NgxWrVqxWeffUa7du0M7oAA/83hNJ57uYbUS6MD524AEOJXSa/zHVzs6TCkNR2GtCYtJZ1jO0+x/7cwDm05SvyDRHZ8u5sd3+7Gp443r30yhEadQsSQu4mlqgveyGD77/NJylJ21urbe0pJdckgppqrqc/uTQWJjVS2onWtGlwm5poKwtPs0TmcchmYw/n9998/8Zy5c+eWTMA5ZswY3n77bQYMGECHDh1wdHTkn3/+4bnnnhMBZ2HJ2VtaSsZb3JOzj3oVWzejtWkstx/E8/uh8wB0aBhg8POtba0I7d2E0N5NyMrM4sy+C+z/NYy//7ePiLORTO06mwbP1uXVT4bgH1Ld2N0XBEEQhCdSoVt7xnSb+OpvwoQJhISEAMoGL4cPH6ZGjRq4ubkRExPDhQsXaN68eaHaNrgOT2pqKi+++CLm5ubaDJKLi4vIJhWSso90RvY94wWcEcnRAFS39zBam8by1bZDZGk0NAuqSsMa+a8E1pe5hTn129Vl7NLhfBe+lOff6I6FpTnH/zrD6w3fYf4rnxN9K8ZIPRcEQRAE/Zir8t5Kuz59+rB79252795Ns2bN+Pfffzl9+jS7d+/m9OnTHDx4kLp16xaq7UIFnJGRkTrH7t+/T1paWqE6IGT996VknALtiZmpxKQriweq2lV4wtkl6/q9WLYeugDA6z2NW0rF0dWBUQtfZuX5xbQZ0AJZltn57R6GBY5n9bR1JCcUfacEQX8TB33MxEH5b412NTmJmIx0YjLSS81WkS6uDsU6DB0Xm1gsrzWn3eN/fY2ta1VsXauK4XRBKAXMADPkXLfSb9WqVdqvDx8+TMOGDXUeb9SoEefOnStU2wYHnG+++Sa1a9emf//+hIeHM2zYMEJCQnj77bcL1YFyT87472sjDannZDfdrRyNso+6Ma34/SAaWaZ1PV/q+HgWyzW8fCvy3ro3WHJwNnVa1iQ9NYO1s39haI1x/L7iz+yssiAIgiAUn5w5nLlvoCwaqlWrFp9//rlpO/gEsbGxnDlzRufYyZMniY2NLVR7Bs/h7Nu3L9WqVWPlypXUrVsXKysrNm/eTOPGjQvVASFXwGmkIfUbSUrAWa2UZTdPX7vLzmOXARjdQ/+tEQsrqGkNFu39iAObjvDNuz9w6/JdPhv9Fekp6Tz/RvkqZl7ajBkwQ/u1oVk/YxYvz09xtGvIazT0+jnnJ1ZriZd30aaoPElRFjQJQnnzaFkkTRlYNJTb+++/T6NGjQgJCcHd3Z2oqChOnz7N2rVrC9WewQHnpEmT8PX1Zfny5YW6YGkTHR3N3bt3tfetra1xcXEhKyuL6OjoPOd7eSk1Ix88eEBmZqbOY87OztjY2JCcnExCQoLOY5aWlri5uaHRaLh//772uJx1F/mhCx5u6VhI5sTGxpKenq7zXAcHB+zt7UlNTeXhw4c6j5mbm+Pu7g6gfR03bkfimCxR2c6GzMxMLCwsePjwIampqTrPtbOzw9HRkfT09Dx/sahUKipWrAgoUyZydhzI4erqipWVFQkJCSQnJ+s8ZmNjg7OzM5mZmTx4oCxeylJrWLR2O07map5pVJeAKu5ER0eTlZWl89yc9zApKYnERN3/pK2srHB1dUWtVhMVFcWjKlasiEqlIiYmhoyM/wJ536beLD70MZsW72DdJ7/wv0UbqeDvTEAjPwAsLCyoUKGCznuYm7u7O+bm5sTFxeWZOmJvb4+Dg4POe5jf50YQBEEoXywkMM+1vqWsLXXp27cv9erV48cff+TOnTs0b96ctWvX4u/vX6j2DA44f/rpJ/75559CXaw0+uWXXzh06JD2ft26dXnuuedISEjgq6++ynP+Bx98AMCmTZu4deuWzmN9+vShXr16nDt3jj/++EPnMT8/PwYPHkxmZmY+7XZl0tC9WAA7duzg8uXLOo927NiR5s2bc+3aNX766Sedxzw9PRk5ciQAK1euRJ1diqYVlmQRTlxgHB4eHvzzzz+cOHFC57mhoaE8++yz3L17l++++07nMQcHByZNmgTA//73vzzB38svv4yPjw9hYWHs379f57H69evTs2dP4uLidF5rdaCaG0x8Tqnl9csvv3Dv3j2d5/bt25fatWtz5swZdu7cqfNYQEAAgwYNIi0tLd/vzbvvvouVlRV//PEHV69e1XmsS5cuDPmgH5FRN8iqmMKe43+z5/jfAFSpUoXhw4cD5NvuuHHjcHV1Zffu3XmGF1q3bk2bNm2IjIzkf//7HwB37tzJ00ZZERebWOJ/eRc2o1fcmc6yxsGtik4mtSjvy8SVb5GW/Ufm+x3GUdmnepHbFJ4O3/38MfHZyZbxAz8ycW9Kt0fLIqnKQMA5ceJEunfvTuvWrbGwsCAgIIBp06YZpW2DA86GDRvi4+OT5/iKFSu0gU9Z8txzz1GvXj3tfWtrZc6jo6PjY7dv6tWrV74ZToDatWvj7e2t85ilpbIgyMLCQqddOeMkcsKHWFsrq8k7depEmzZtdJ7r4KD8kvf19c3TJ3Pz/76FOUHTx2d+5nLiXV4P6IiLiwsAzzzzTJ5pD3Z2doCStX20XZXqv+m9L774Yr4ZToAmTZpQu3ZtncdsbGwApXrBa6+9RkxCMm9/9TtpGVmM6NoUFwdbQHnv88twghL4P/o5s7JSCsRbW1vn+72xsFCmJHTp0kUnwwnK91OSJF7/+FXef342ty7fxaduVSZ9NQpbOxvtefm1mxOAtW3bNk85CHt7e0DZhSHnuadPn843cBUEQRDKj0fLIpWBReoEBgayePFiXnzxRUJDQ+nevTtdu3bF07Poay4MDjifeeYZXnrpJfr27auzu1BZDTjd3d21w+S5mZub53s8R84QbH7s7Oy0wdyjVCqVTrty6glkqzgwV4Z3cwK5/NjY2GiDufzktHvzUjIJdjIB3r7aIMzZ2bnA3aCsrKwe+1pzhtbz4+joWGBGzMLCAi8vLz79/Xfup8jU863CoE4ttY/nTAXIj729vTaYe5SZmdlj++vmVnDtURc3Z6aunMSYxu9y7s/L/Dr3DyZ8+V+Q+bh2c4L3/OR+D/Mbli8rCpPBKslM481L51h3VJk/5Jb9R9yIfh8U+3WLqiTeGxdXhyKvgs95vpe1FclZymiJJivjcU/J484NZVMHGwdXkREtgptXLnDlijJS1r7rJBP35j8vP/++qbtQZpTFDOfo0aMZPXo0aWlp/P3332zdupWPPvqIChUq0K1bN7p3717oNTsGB5xTp07F09OTffv26RzPPS9RMICcPddTZZxhzHR1JtFpSpuVbAoOkErK0cuR/HX8CmYqiamD2qMqBT9xlfw8eXfNOKb1mMvWr/5ixLzB2DnamrpbgiAIwlPk0a0t5Vyr1Ev71pbW1tZ069aNbt26AXD27Fl+//13Jk2axLVr1+jYsSOrV682qE2DA862bduybdu2PMf79+9vaFMCgJy9kEfKPyNqqMiUGGRkHMytcbE0TpuFpdHIfPqzMt/3+Vb1CKhScEazpFUNUlbzmluYYW2b/17ugn5KMosVfnUn399SsnAVssvWdrh4hmo1C1eIuKz7c+tCOnR7U3u/qN+LnOcPbTOWlLjbAHj7BxrUho2Dq1H6Ut5VrRFE1RpBpu6GUARmgHnugDP737KySj23OnXqUKdOHd59913u3LnD3r17DW7D4IAzv2ATlL01hUKQs1c9S8apl3k9SVm9Xc3O3eS7P+04eokLN6Ows7bkta7NTNqXR0WcUzYv8K5ZGTPzslCOVxAEQShLyuKQ+qNkWeb+/fs66yIGDhzIgQMHDG7L4IDz5s2b+R4fPHhwoTpQ3snaDGfBczMNcSO76LuPvWmziRmZWSzbpKxef7ljI1xL2ZD1jeyAs1rt4q1bKAiCIJRPZtm3HJqCTiylvvnmG958802SkpJ0NkwpbDLL4IDTx8cHSZK0Fzd1Fq3M02Y4jRNwRmQXffexM+0e6hv2nuJubAIezva82L6BSfuSn4jzSsDpU7uqiXsiGKJd1zeof2MiAB6WyoI4Rw+fMl0iac8fiwFo02Wi9lju1/O415Z7ON0Ycq5VsbIXVC54Ad3jlMXvQWnl/P4EAB5+/JmJeyIUhkqSUOWKkVRlLF765JNP2LVrF8HBwToVcbp27Vqo9gwOODt37qwzrP7w4UM2b96s0xnBALJSNF0yUsB5JUmpa2nKDGdaRhardxwBlB2FbCyNs4OSsUTdjCZsm1KTtHpdEXAKgiAIxmcuPTKHs2zFm9SrVy/PXuoAn31WuD+AijyH09nZmZdeeonOnTvzwgsvFKoT5ZomTvlXVfQV5Q/SE7meFIWERD1n0wVSWw+f52FSKpXcHOnWtHRNes9Iy2BG34UkxiZRo6EvDTsGm7pLpU5p2b7w+tmjAFSv00jn+GDvygDcSVOmo5wNW02dJsNKtnNGFJGsuytZxIVT2DoppcjW/7qEBl71lQcCWpXY96W0fAbKsxsXz/BeTfE9KMvKYh3O3KZNm8ZHH31EgwYNdBY5TZw4kePHjxvcXpHncKanp3Pq1CmuXbtm8MUFQJO9paSq4Pqb+joao+yuE+johbOJVqhrNDL/26VkD19oVx9zs9L1I/bFhNVcPnoVB1d7PvjpLSytSlf2VRAEQXg6lPUh9U2bNjF79mw8PDx0RrELWwazyHM4LSws8Pf3Z9GiRYXqQLlnxIDzSHbA2cjNr8htFdaB8xFE3IvF3tqSXi3qmKwf+dm+ahdbv/4LSZKYunYiFauVnjJNpYkpMluXDykjJ0vOKtuNRqWrae/uDED/SoE6fTqXEA/AL/eUzKCD+QPelVcCuvMgi2rVTx9Ry1HZRKBZx+Krledr56Rz39zKjo37vgRg2fU4fCN3APCdb9M8hd2N/b0SWc2i2bF1ARUsHWnYoeBd6vRVrWZd3i6n5b6eFgWtUi8LdTgB1q5dS2RkJB4eumtCXnnllUK1Z3DA2bp1a3bv3l2oiwn50MQo/xYx4JRlmbCYcACauPkXtVeF9sNfxwDo07IudtaWJuvHo64cv8aSMd8A8PJHA2gkhtIFQRCEYiShO4yeE3uWlTqcISEheYJNgGHDCjeFyeCA8++//y7UhYS8ZDkd5OyMRREDzlspsdxPi8dCMiPEpZoReme4k1dvE3YpEjOVxMC2ISbpQ37O7r/I9F7zyEzPpFmPhgya0sfUXRIecTn6LAB7YzMBSMqEWg5pec47tetbTiUoC+0uxSu/vqvayyQZuP2iPjI1Gs7GPwCgOKvIPtNlgs59O+eKuFgof6w5WIA6u1z0lRPr8KnVGwDr7KyomGtZunTq9papu/DUef+7d/j45Xmm7kahmEsS5rmG0TVlbEg9KCiInj170rFjR50Aee7cuZw/f97g9gwOOP/3v/+xbt06fvnlFy5dukSvXr2QZZkffviBVq1aGdyBck2tlOZBsgPJuUhNnYi7DkAt5ypYm5V8ZlGjkflkwx4AeraojZdr6fjrbe+PB5j38jIy0zOp2cSfd74bh0pVuuaVCoIgCE+fR7e2NCtb8SafffYZISEh/PzzzzrH7927V6j2DA44V69ezbp167C2tmbKlCmMGDGCli1b8u6777J///5CdaLcyopQ/jXzKXI90xOxSlv1XaoXrU+FtPnQOS5GRmFvbcmYHqEm6UNusizz4/zNfPPuDwC06NWYKf+bILaxLKW695gMwPpbEwG4k66hvrNSuSF3Bu9e6gN6eSlDPN+PmqI859dZhIaONnqfRvb/0Oht6sPF1YEWQd0BiEr/iVS1Ui76lzs3Sb75KQAB9spGCl18muLSvLtJ+imUD2E7v6RJR+P+fLVbPJ5dE5fodW5ZzW6CUqc89//tZa1ueZ8+fVi1alWe4wEBAYVqz+CAU6VSUbFiRaKiojhx4gRbtmzBzMwMKyvxH7nB1DeUf82LPgSek+Gs7+JT5LYMlZSazrLflD82XuvWzOS7Cqmz1Cwbt5LfV/wJQJ/xXRm58CXMzMQWloIgCELJKOtlkVatWsXRo0cJDw/X2dqysHXXDX5WUlISYWFh/PDDD/Tv3x8zMzM0Go1OZ4ri7NmzbNy4ESsrK3bv3s13333HrVu3+Oabb6hSpQoajYYPP/wQgPDwcObMmYOfnx9RUVEsWLCgTBWgl3NlOIviflo8d1LjUCFR16Xk629+ve0wsYkpVPNwYUCbkBK/fm6pSanMGrSYw1uPI0kSoxa9zHMTupm0T4IgCEL5U9b3Un/ttdf47bffCAgIwMLivxKCJTakPn36dHr27Imbmxt//fUX9+7do1u3brRv375QHcgtKyuLt956i23btqFSqRg4cCBOTk48++yz7Nu3Dzc3N/r378/u3btp27Yto0aNYuHChQQHBzN58mTWrFlT6NVTJpGd4ZSKmOE8EatkNwMcK2Fvbl3kbhkiMvoh63YrdTff7NcaC3PTZRHv34hmeu95XDt1AysbS6b8bwKhvZuYrD/l0cw1yjD3kfgUNo01fDeKftnbKUanp9Ege4FMbioknu81RefYwD7vGd7RUs4nSKmi8HJFX+5fUBZqbrtxjP0p2UXik1IA6CyXtd2Zhdw++l75LE9/aY6Je1Iwi2JYE6DvcHpZV9YXDR08eJCbN29iba0bV0ydOrVQ7RkccHbt2jVPdHvs2LFCXfxRYWFhqFQqlixZQmJiIoGBgTRo0AC1Wo2bW3Y9vGbN2LZtG6GhoRw4cIDg4GDt8XXr1pWtgDMru1i+mW+RmtkXdQGApiYoh/T5pv1kqTU0C6pGyzqmmT8KcGbfBWY8P5/4B4k4ezjx0aZ3CGpaw2T9EQRBEMo3CQkVks79siSnXuij6tevX6j2DA44L1++zKFDh3jhhRfIzMzkk08+QaPR8NZbb+HgULTyHJGRkRw6dIgNGzZgb29Pu3bt+PDDD3XadXR05PTp08TExGBra6tzPDo6usC209PTSU9P195PSkoqUl+LStYkgCZKuWNe+ELtmZosDjy4DMAzFUt2G8lzEffYeewykgQTnzNdhYKtX/3J0rErUWepqdGgOh/+OhkP7wom6095kLsAec6inrjYRKYNKVqmpnHwQAAqVcs/69+h25tFar8gB3cso3mnsUD+r82UMjOV31V25mbUdbABoLqdspNYzRY9TdYvoWiaLxzPwTdLf6avfvvhRm/z1vVrVKletERLWVDWh9Rnz55N7969CQoK0imL9O2339KvXz+D2zN4Dus777xDXFwckiQxffp0tm/fzs2bNxkxYoTBF3+Uo6MjNWvWxMHBAUmSaNasGfv27SMx8b//ABISEnB3d8fNzY2UlJQ8xwsyZ84cnJyctLfWrVsXub9FkqXsCoSqIpLKvtDNHIu9TnJWOm5WDtR2qmKkzj2ZLMt89uu/AHRtEkRAlZLftScrM4ulY79h8aivUGepaTOgBYv++VgEm4IgCILJqbIznLlvZcno0aO5c+cO9+/f5/r169pbWlreGsn6MDjDmZyczIQJE8jKyuKHH37gxIkTeHp6Ehpa9FI4TZo04cGDB2g0GlQqFTdv3qRnz56oVCpiYmJwc3Pj0KFDjB49GktLS1q0aMGpU6cIDg7m0KFDdO3atcC2p0yZwqRJk7T3T548adqgMyfgLEJ2E+CfKKX4aiv3mqikklsDd+BcBEcvR2JhbsboHi1K7Lo54h8kMHPAIk7uPgfAsJmDGDSlT5krO1FW5Zf5e/RYTqbQkCxhQZnN4vLPH8o8068irvPbaqU0UzfPykpfKgYDDQHTZTpdXB14WKEmAB7xt3DKnrgf5FTZJP0RjKexU+nZia2klYfsJoC5SrnlUJexZeo3btzgxIkTeY4vWVK4zLzBAWdCgjJpfcuWLTRo0ABPT08AbGxsCtWB3Nzc3Pj444+ZMGECLi4ueHh40L9/f6pXr84777xDpUqVCAoKom3btgAsX76cWbNm4evrS3p6OkOGDCmwbSsrK53STfb2hc8qGoOcpWxDWZSAU5Zl/om6CMAzHiU3nJ6akcmnv/wDwMA2IVRyK9ki7+EnrzPj+QXcux6Fjb017/4wnhY9G5doHwRBEAThcR7NauZ8XVb2Um/WrBkJCQl5tuEsbGLH4ICzefPm1K5dm9u3b/PTTz+RmprK8uXLdeZTFsWAAQMYMGCAzrEmTZrQpEne1cb+/v6sXr3aKNctcRkHAZAs6hS6iYsJd4hKi8fGzJLGbkXLlOpLlmVm/e8vrt2NxcXehlc6l+wq8D/X7GXxyBVkpGXi5VuRjza9g09t7xLtg6Cf4sgKGnsrR3d7JVNoLkVwPUUp7bbsmlL1oWPSQ1rnbJnp3/yJ1y1MRlcf1es00vnX2Ax9T4vrdZY3S0YsKFXv5b7tS7ibpswX7t+7cKuQBV2SpNxy34eys5f6w4cPqV27Nk2bNtXp7/bt2xk3bpzB7RkccC5atIgdO3bg6upKkyZNSEhIwNXVlQULFhh88fJKVt+GrAuACqwKP6y/N3s4vVmFGliZWTzhbOPYsOck28IuYqaSmPdqN5zsSqYMU2ZGJssnfcfmL3YA0LhLfd5dMw7HUvCLWhAEQRAeVVCGs6w4ePBgvutzCrvRj8EBpyRJdO7cmdjYWM6fP09QUBBDhgwR+1MbIm2X8q9FAySVa6Gb+ee+Ug6ptUctY/TqiY5fucWin5Sh9AnPPUOjgJLJLD64E8vH/Rdx/sAlAAa/35chH/QTn7lSIidLc+3YOuIzkwEICOpVLPO0jJ0JCmrVF4D3bJzZkF3v8rtbymvYHxtLn3jlD5xRqQ9waf1CifatuOVeja9vpi33c8qT37d8ot1+1VhK23sZmZKIlZn4nWpMZX2V+htvvMH48ePzHPf2Ltz//QZ/umJiYujZsycVKlSgR48ePHz4kODgYE6dOlWoDpRHcrryH5tkXfhi+bdTYglPuoeZpCLUPdBYXStQ1MMkJn+9lSyNhi6Na/Jiu8LV4TLU6X/O83rDyZw/cAk7J1s+3vwuL88YIIJNQRAEoVQzyy78nnMzK2OLWvMLNgFeeeWVQrVncIZz9OjRNGnShMWLFzNs2DBcXFz4/fffefXVV9m5c2ehOlGeyJpEyAhT7lgVPuDMGU4PcfHBybJ49y7PVKt5+6vfiU1MoUblCkwb/GyxrwaXZZlfFm/l63d+QJ2lpnrdqnzw81tU9vcq1usKeelbl/LLaxe5m64GYLT6J6pUN25GCODamTB86xp/3nAF36Z0T4gE4Lf7yqrMB6kQnpJp9GuVFoXJyJa1LK6xGDu7CaXvvXzhucfv2HVyl7JeIqRdGdpcpRB+3TQXtSzTt/eUJ5/8BJIk6fxfWd6rqBgccD548IBp06YBaCvQV6tWDbVabdyePa3S9wBZYOaHZO5TqCbUsoafbx4GoE3F4h9O/27nUc5cv4uDjRULR/bAxrJ454smxCQy/5XPObRF2cGq3QstmbhiJDYlNF9UEARBEIqqrM/hNDaDA87U1NQ8y+STkpJ0irALBZPTsrPA1h0L3cafd08TmRKDo4UN3Ss3NFLP8nftbgxfb1OC23cGtqWKu3OxXu/s/ovMHrSY6FsxWFiaM2rRUHqM7lju/zIUBEEQyhYVj8zhNFlPSgeDA87BgwdTt25dBgwYwK1bt5gxYwY//fRTqa4lVVrIcipkKItupEIGnGpZw6qruwF4waclduaFWy2m17U0Gj764U8ys9S0rFOdLo1rFtu1NBoNG+Zt4tvp69GoNVSu4cW0DW/gH2K6/dkFRe6tKx8VF5vIvfN/AnA8IYuYdOW3642U5CcuRClMSZjiGE7X9iEkewFR4n0ALicl0tmrBgCWVs7Fct2yIr/vfWkbEhaKV2kcSr98eDsBTTsbtc0+vd5lzx+LjdKW2SPzNsvaHE5jMzjgHDNmDBUrVuSbb77BwsKCgwcP8sEHH9C3b9/i6N/TJX0fyKmgqgzmhRsK//veGSKSo3G0sKF/teZG7qCuH/ec4vS1u9hZWzJ1UPtiyzLG3X/IvJeXcWynsvCs/YutGP/Fq9g6FH0zAUEQBEEwBTGkrsvggHPJkiVUrlyZ7du3F0d/nmr/Dad3KFTwppE1rMzObg6qFoq9efHNabz9IJ6lm5S90if0aYlnMWUzTuw6w9zBS4i99xArG0vGLhtBp6FtxBB6KeTi6sD5fT8CkJQaA0CTjqOhVgcARt05Q4ZGmcv9Qoe3HpsBK20lYeC/jF2bVspoTRv0z+LduhaOnXNFnXaM5crRvwDYcOFv3CyV7RD7tVVWj1bwcDPqtfITF5tI9JX9AMTGX6VipabZjyjVMUSmUzAVY2c3c7TpMtEo7ZT1skjGZnDAOXPmTDZv3lwcfXmqyXIGpCvBomTdoVBt7Lx7mutJUTiYWzOgWvHtXx6XlMobX24iLSOLhjWq8FzLeka/hkajYd2cX/n+gw1oNDI+tb15b/0bYtcgQRAE4amgkiRUuZInqnKeSDE44GzWrBnNmjXLc3zTpk306tXLKJ16KmUcBDkRVO5g0cDgp6epM/n8slKEekj1Z7C3KJ7sZkJyGmOW/EL4nRgqONnx4UsdURn5z7KEmETmvrSUI38o5Wc6DW3L2GXDsbYtvvmognHUatW/wMde6/+BQW2VRGasMHMPC9Ov1AfXSIu/k/38Zwx+/uPsizgAwE/3kvGwVIrSex78GlDmm330vVK+paqtDUP7TjfadXPeu1unNzH97BEAEtUyPWOVOa7d1Ep2ycVV94/fSwd/ByCweXej9UUQyiIp+5b7fnlmcMDZvXt33n//ffr164ezs7P2+Lx580TA+RhymhIsKsPpZgY/f13Efu6nxeNp7cxAn1Aj906RlJrO2GW/cjEyClcHW1ZM7EvlCk5GvcbFsCt83H8RUTcfYGltwbjPX6XzsLZGvYYgCIIgmFpO4ffc98szgwPOUaNGATBr1iyd42LOXcFkORPSlHlYkpXhc04epCfy3bU9ALwe0BHrYtg3PSUtg/Gf/8bZiHs42Vnz5YTnqe5Z+G03HyXLMpu/2MHySd+Slammkr8n0ze+iV+wj9GuIZhGaS4gnhSrZB0trO0B8KxSuViuU6NJ4cucPUlD16oA1ImOxdlC+WO1gtV/mz1Mf2lOsV0b4EzsDcLicu5JBNgqWVYuKPP46989Sp0mygrm9X8uYGf0QwB+FRnOUqfGnPFcmbLE1N0oN0Thd10Gl4Vq3bo1Go0mz+2ZZ4w7jPRUyQgD+SGoXMGykcFP/+rKX6SoM6jtVIWOXsafT5mWkcXELzdz8uod7G2s+GL8c9SoXMFo7acmpTL7xc9YNm4lWZlqWj3flC+OzBXBpiAIgvDUUvHfSnXlZphr167Rp08fBg4cqD0WHh7O8OHDmT17NhMnTiQrK8uofS5OBmc4C1ow9Pfffxe5M08rOe0P5QurZ5Ekw97yq4n32HzrKAATa3ZDJRm3dGx6ZhZvrtjM0cuR2FpZ8Pm4PgRVrWi09q+eimDWwE+JvHQHM3MzXvtkCH0mdC33f+kJJcPbP9DUXSiy4HZDAfihXdHa0XeL0kfP6dJmPKfiPwbgfnomD7OUSgT/xiQAkKpWY3d8PQAWKhVZctH6KRSfCpam7kHJ+3yDMrd8zIAZJX7toq5SP3z4MJ07d2b37t3aY6NGjWLhwoUEBwczefJk1qxZw7Bhpa9Gan70il7i4+MZOnQo7u7uBAYGMmnSJDIzdfcYVqnKew39/MmaWEhVgnTJuofBz18R/hcaZNpWrE2wSzWj9i0zS83kr3/n4PkbWFuas2RMb+pWN85e5bIss+nz7YxrNpXIS3eoUNmVBbs/5LmJ3USwKQiCIDz1cgq/574ZYtCgQVhZ/beYNiMjgwMHDhAcHAwoi7i3bdtm1D4XJ73SbePHjyciIoLp06eTmZnJd999x6xZs/jwww+LuXtPgZS1QBqY1wZLw3ZJuRh/mz33zyMhMbLGs0btVqZazZSV29h35jpWFmYsHt2LBjWqGKXthNhEFo34kv2/KStbm3VvyFurXsepguMTnikIgiAIT4eCyiIlJCTonGdlZaUTWBYkJiYGW9v/5m87OjoSHR1tpN4WP70CzpMnT3Ls2DHMzZXThw4dSvfu3UXA+QSynIacvAYAyW64wZm9FeHKQqNOXsH42htvmDtLrWH6tzvYdTIcC3MzFo7qSZOaVY3S9tl/LzD7xc+IjozB3MKMVz8ZQp/xYgi9PDB0yLYwDu5YhrNdJQCCWj6X7zlXTyobFty+e4xnukww2rX/3LoQUP7TaN91ktHaLarY7KFtV7fH/0FX2O+Ji6sD41q/BsC5C7+x455SFiklu8i/jZkZcRnK976Nbyu8bY8X6jpC8fuyfn3u374LQMXKxhnNKu0qWhXfBilPokJ3GDnna29v3XrTH3zwgV7xlJubGykpKdr7CQkJuLu7F7mfJUWvgNPFxUUbbAK4urrmicaXLl3KuHHjjNu7si71F5DjwKwKWBu2Ov103E32R1/CTFIxwr+Ik7dyUWs0zFizkx1HL2FupmL+a91pUcun6O2q1ayf8xvff6gUcq/k78l76yYS0NCv6J0WBEEQhDKmoFXqkZGRODr+9weiPtlNAEtLS1q0aMGpU6cIDg7m0KFDdO3a1bidLkZ6BZwpKSmcOXMGWf5vNnhycrLOsTVr1oiAMxdZViMnrwJAsh1q8GKhr7Kzm10r1aeqnXFWjGs0MrP+9zdbD1/ATCUxd0Q3nqnrW+R2H9yJZd5LSzm56ywA7Qe3YvznYi/08qY4Sx3t2LoAgBvJydTMzqwFFXCuX0hLAMJvH3psm3GxiQb12SF7s4XEzDS9n1MSSmL0oIqvf/a/b5G55RMA7qSmAmBlpiIz+3tibuNCk+Yji70/QuGEtCsbi0uMqW/vKdqvr587BkD12g1L5NrSI3upS9lfOzo66gScBdm6dStbtmzhypUrLFmyhPHjx7N8+XJmzZqFr68v6enpDBkypNj6b2x6RUFHjx4lJCREJ+AECA4ORpIkZFkWQ6aPSt8L6psgOYFNX4OeeiD6EmEx4ZhLZgz3M052U63R8NEPf7Ll4HlUksTMYV1oF+Jf5HaP7DjJJy8t5WF0AtZ2Voz//FU6vNTaCD0WBEEQhLLL/JHC7zlfN27cGDMzM8aMGcOYMWMKfH63bt3o1q2bzjF/f39Wr15dPB0uZnoFnE2bNmX9+vUFPi7LMoMGDTJap54Gcuo65Qubvkgq28efnEumJotFF7YCMKBacyrZuhS5L1lqDR9+v4NtYRdRSRIfD+1Mp0ZFKxeTlZnFd9M3sH7ebwD41qvGtA1v4B1YPIW1hfItU6MBlPmCrrbKnKWcOaMFZSk7dXvrsW1+svlj/OzsAHi+/STtH9QZqUq7jxaJb9ax4P8YCnJyl/IfQ3RqLNUrNQbAv75xaxaXVBH9HIFeyta8Lg8uAJCuycLTQXmvfGrVL9G+CIIh7kQq28SWWIZTUm657wMcOXJErwzn00avgHPJkiVUq/b4kjxLlojdC3LIWZGQ/g8Aku0Ag5674cZBbqY8wNXSnuFGmLuZqVYz/dsd7Dh6CTOVxOxXutKhYUCR2oyKfMCsQYs5f+ASAD1Gd2LUwpewtC6HRd4EQRAEIR8FrVIvr/QKOBs3bmyUc8oLOfVHQAbLUCRzH72f9yA9kZXhuwAYG9AJe/Oira7LzFIzddU2/j4RjrmZirkjuhV5GP3glqPMH/Y5ibFJ2DraMOnr0bTu17xIbQqlx7UzhwkJ7WDqbuQRGjpa+7WxMnpzhn6icz8nY2pl+/jMgyFzP8/E3QZAg0xNR89C9NJ4ou5GkRxzE4DqdQzf8SxHjUZKibYaKP/euXkTc/O8f2zeuXmTpLvnSUpOLvS1BMGYQjsr60x+3/IJ/m41qdmiZ7FeT/XIHM6cr/UdUn/aGLzTkPB4spwBqT8BINkOfMLZur64vINkdTq1narQtXLRhqYyMrN4d+U29py6ioW5GfNf616kBUKZGZmsfPd//LxYGe4PaOTHtPVv4OVrvHJNgiAIgvC0eLTYe87XYkhdMI70v0ETAyoPsNJ/SPzsw0h+v63Ur3szqEeRtrBUazRMWfUHe05dxTK7zmZobZ9Ct3fjwi3mDVnClePXAXh+YjeGz30RC0uLQrcplE6+dZuaugv5Kq55irnngep7DUP6cjFRaV+DTED4TgC8/fSf0mLoSvrH8fDyAC+PJ14vh77XtbF30Z77+YYPsMredc7f3gkzSUVycula1S8I3XtMLpHriCF1XSLgNDI5RcluYvM8kqRfQKaWNXxyXtn+slulBtRx9n7CMx5zfVnmkw172H0yHEtzMz57vRdNgwq3JaYsy2z+Ygdfvf09GWmZOLja89aq12nRU0yfEARBEITHKajwe3klAk4jktV3IUPZ5USyeV7v522+dZSLCbexM7dibGCnIvVh1fYjbPznFJIEM4d1LnSwGXM3joXDv+DI9pMANOwYzFurXqdCJdci9U8QBEEQyoOCCr+LOZxC0aX+Bshg0QTJXL+tIh9mpPD55R0AjPR/Fjerwg+fbT54js837wfg7X5teLZB4Vaj7/vlMItHriAhJhFLawtenTeEnmM6oVKV97/Pnn4LNsygr38w9dq+ZOquFIvjf33NhQRla8YXn5tW7CWF7LN3aEvXqMmSNYVq40nln4qDi6uD3tfN/fiYATN0Hhv/zVtkpKYbv4NCufXzpjk832vKk08sBQoq/C7mcApFIssycurPAEi2+mc3l1/ZSUJmKn72FelbtVmhr7//XAQf//AnAEM7NmJgW8MXHaUkpvLFhNXs+HY3AH4hPkz5YTzVahV+iF8QBEEQyiMzlQqzXIkas3KetBEBp7FkHs3eWcgOrPQbFr8Yf5tfI48A8HatHpirzAp16TPX7zL5699Ra2S6NqnJ2F4tDXq+LMsc3XGSpWNXcvfafSRJov/bPXn5owFiYVA589aADzh14FtuXlGKeletUdAGkqVffgtuJEnFw8zMEuvDc35KybCUlPv41O9fYL9Ki5x+vbnqbXztlA0rxgyYUegsa4izI6mWYtGQ8Hhrf5mFuUrJ/vXvPfWx57ZrNbYkumQUYg6nLhFwGomctEL5wrqrXjsLZWqy+PjsL8jIdPSqRwPXwpUs2n8ugslf/05qeibNgqrywZCOqFT6r4S7cvwaX7/zAyf+PgOAR9UKvPP9OOo9U6tQ/REEQRAEoeBV6mIOp1BocvohyPgHMEeye02v56y+uocriXdxsrDljZrdnvyEfPx++Dwfff8nWRoNzYKqMv+1HliY65clvXv9Pt++v55da5VFThaW5vR8vRNDPuiHnZNdofojlH1xsYn41OhsUOmewrp/+y4AFSt7FUv7+WXj6rcfTkluvhjYvLv265ws4Y69SzgTnwBAX+8A6rcfXuDzTZUJTVVriE43fO7lo9nbPu3eICEhgbHMMWb3hKfMC8+9p/e5pXV0ID8FFX4XcziFQpFlGTlpvnLHdgCS+ZNXhV+Iv83qa3sAmFyrp8ELhWRZ5vs/j/HZr/sA6NK4Jh++1FGvYDMhJpG1s35m8xc7yMzIAqD9i60Y+vFAPH0eX6NPEARBEAT9SDyySh1Rh7NUmT9/Pjdu3MDW1paMjAw+/fRTjhw5wjfffEOVKlXQaDR8+OGHAISHhzNnzhz8/PyIiopiwYIFmJuX8EtK3wGZZ0CyRbJ7cmo8Q5PFjDMbUcsanvWsSwevegZdTqOR+fSXf/jf30qR+MHtGzDxuWeeOIyenprOr59tY/2830iOTwGgfvu6vDpvMDUaFH4HIuHpEnXxbxp3LpkV6pY29o99vDDzBqPu3MPC2s7g5xW3uNhEUhIeALDudhRnE2QA0jQXC5VxLa6V6zntfvHqQp1jj7tOXGwiyQ+Vlf/XLm3FN1AZsTl29mfszS1IThFzOIXySdlpSKVzvzwrVQFnXFwcc+fOJTo6GpVKRe3atTl9+jRDhw5l3759uLm50b9/f3bv3k3btm0ZNWoUCxcuJDg4mMmTJ7NmzRqGDRtWYv2V5UzkxEXKHdthSGYVnvicr6/8zbWkKFwt7Zhcy7B9XDMys/jw+51sP3oJgDeef4YhzzZ87HPUajV/rfmH76ZvIPpWDAC+wdUYMXcwjToG6/z1JQiCIAiCcagklc6ugUXZQfBpUKoCTisrK6ytrUlKSsLW1hZra2vS09NRq9W4ubkB0KxZM7Zt20ZoaCgHDhwgODhYe3zdunUlGnCS+iOoI0DlimRX8DysHMdjr7Pm+j8AvFO7N86W+s+VTEnL4K2vtnDowk3MVSo+eKkj3ZoWvIJYlmUObj7K6mnriDgXCSgLgoZ+PJD2L7YSNTWFfAW26M3aX2YVOKfKmJk1fdswZFV3TnaztMnd/xYu9lS0TAWgsYszUXejgOytJ00sp5+53/OC3vucz4JGncWI35cAcDRGYti9rwC4n57J96M+JSEhAdB/jp4gPC0KmsMpFg2VAra2tsyePZtBgwZhb29Px44dyczMxMHhv194jo6OnD59mpiYGGxtbXWOR0dHF9h2eno66bkmwSclJRWpr7LmIXLiZwBIdmOQVI8fHoxOS2DqyXVokOlaqT5tK9bW+1rxyWmM//w3zly/i42VBfNf606LWj4Fnn9y91lWvbeWC4euAGDvbMcLU5+j19jOWFpb6n1dQRAEQRAK6ZGdhpDEoqFS48SJEyxevJhjx46hUqno27cv58+fJzExUXtOQkIC7u7uuLm5kZKSkud4QebMmcOMGTMKfNxQctIykB+CeQ2wHfTYczM1WUw5uZbYjCT87T15p1Yvva8T/TCJMUt/IfxODI62Viwd24e61fNf1Xv52FVWvbeOYztPAWBta0WfCV3p/3Yv7J1LZ+ZHKH1eeO49lqyfDoCjuTk17F0ACO08ziTzIg25Zmmat/monL698+Is7bHC1uQs7tepT/sP714GYOuZTZyJV/4jTU6HaynKH/YOZipeWv6G2GlIKFHjv3kLgCUjFpi4J2AmmWEmmencL89K1bjq7du3qVChgna419PTk5SUFFQqFTExyvzDQ4cO0bVrVywtLWnRogWnTp3SOV6QKVOmEB8fr73t3bu30P2Us8Ih5X8ASA7vIUmPj9s/u/gHpx/exN7cmnn1X8TGXL8sY2T0Q15ZsIHwOzFUcLLjm0n98w02Iy/d5qP+CxnT+F2O7TyFuYUZPV/vxHfhS3ll1gsi2BQEQRCEEiZJqjy38qxUZTg7d+7M77//zuTJk7G1tSUhIYERI0bQvHlz3nnnHSpVqkRQUBBt27YFYPny5cyaNQtfX1/S09MZMmRIgW1bWVlhZWWlvW9v//gh8ILIsoycMAtQg9WzSFYtHnv+9jsn+fHmQQBm1OuHt52bXte5cvsBY5b8zIOEFKpUcOLLCc9TuYKTzjlRkQ9YM2MjO7/bg0atQZIk2r3Ykpc/HICXb8VCvT5BEARBEIquoDmc5VWpCjjNzc1Zvnx5nuNNmjShSZMmeY77+/uzevXqkujaf9J3QcZ+wALJ4d3Hnno+/hazzv4KwCt+bWnlod82gYcv3GDy11tJTE3Hv3IFPh/XB3cnJUCWZZkrx6/x53d72fr1X2SmK9v0Ne/ZiGEfD6R63SfXARWEx/no+ymkazQAnM1IIlWtBsDyz+U07jCqxPpRmofHn+RJi6uMufiquEokPcnysA0AHEtIwzX7b/kQJ4lmzko/NMi88+IsEhIS2DDpyxLtm1B+GWso/dSubwEIbje00G08mtUUGU5Bb3LWNeT47CDTbhiSedX8z5NlNt06ysILW0jXZNGsQg1e9W//xPZjEpJZ9PM//BF2EYB6vl4seb03jnbW3Dgfye71+9mz4QC3r9zVPqde61oMn/0CtZoHFv0FCoIgCIJgFAUFnGKVuvBYsjoGOW4EyPFgEYxkPzbf81Ky0pl7bhPb754EINQ9kI/q9dcp/vootUbDL/vOsHTTfpJS05Ek6NsqmIH1A/n9s23s2bCf62duas+3srGkWY+GdH6lPQ071BO1NAWjqmJrw/IbSpHyK/ESKep4ABwtLGhsyo6VIU/KNhozG2mqTPCBh0pB91spUCW7YEhNe0t87ZU5484WVvy6aS4povC7UMz0zfK/vXoyAOlqzRMzoUXJbOZQSWaocq3xUGUvGhKr1IUCyXIq8sORoL4FZt5IzsuRJOs8511NvMeUk+uISI7GTFIxukZHBldv+dhirxdu3mfOul2cjbgHgL+nK60s7bj82Z+8FvbfMJS5hRmNOofQdmBLmvdoiI29jfFfqCAIgiAIRiGG1HWJgPMJZFmN/PBNyDwNkjOSyzdIZnkX/vx+6xjzzm8mXZOJu5Ujs0IGEuLiU2C7SanpfLnlABv2nEIjy1ipVFS9m0Ts1wfZrFG2vVOpJELa1aHtwJaE9mmCg0vhFjoJgiEaV/DlxztKhjM9E26kKfM576WlseePxQC06TJRe76p5hCWVXGxicTfvwaAubUDdk5KObey9v55WCojKw/SZapZK/+RLnxlfp7PiFL43Xgl6Z5GS9ZPJyEzk2lD5pi6K2VCzu8cUH5uCvrZ+erHGZzPLqsYm6mmuYuSVRw9oGQ+jyLg1CUCzieQE+dC+l+AJZLLF0jm1XUeT1Nn8Mn5zfx+W9nbvKlbDT4K7oeLZf7BoSzL/Hn8MvM37CEmUakjanX1AbYHrhOboiwAqh0aSNuBLXmmbzNcKjoX22sTBEEQBKGYSCrllvt+OSYCzseQk1dCyncASE7zkCwb6Tx+JfEu005t4HpSFCokXq3RnmG+bfIdQpdlme37zrJ8034iU5Rt7VTxqdjtu4bl7XhqNKhO24Etad2/OR5VCy5gLwjFrUq9XnyQ/hCAFZZXMc+eI1zN1g5nK6fHPFPQl1NFX1N3odByskuzQpTydMfun8Us1zzy3NlvQT/jB35k6i6UGZcPbWN82HYAotLhu8ZNqNtmcL7nHop7yPcXlCobqGVu+cUBMNrAa77w5UQAlr9o2PdJpTJHpTLXuV+ele9X/xhyyk/IifMAkOzfRrLp9t9jssyPNw6y9PJ2MjRZuFk58HG9/jRy88vTzs2Lt/hu3V7+jLhNkq2FcjBLg83JWwSkyrR/rTNtBrSgSkClEnldgiAIgiCUAJHh1CECznzIaTuQE6Ypd+xGKLdsselJfHz2Z/ZHXwKgpXtN3q/7nHYIXaPRcOnIVfb/ephtB84T6WmL2s0ObC0gU02luHR61w+g45sDqVqzcom/NkF4EhdXB3xq9Qagc8p32pqcThaWhLQbBsCorycB0MTFmVf6TjdJP0ub+f9Tfme8/eLMx573pLmaj85PKwkX/v0FAGsXpY5v9doNCzxX26cgpdTbi6G9i7VvggD//Vy88O92bh1WRgnNM9S8TBh/11O2i37058XfzgYzy2QALMwlAuwKt7Xk2tGLgZz5yPoTczh1iYDzEXL6fuSHkwAN2PRVspvZw0UHoy8z48xPxGYkYakyZ0JgF/pWbUZWZhZHd57iwG9h7N98hLu2ZqTWr4K6tjI0bqaRae7pzvjB7fGvITKZgiAIgvDUKyDDKepwCsgZp5Af/p+9+46v6X4DOP652TshQhAkEjMlsWNvguBnVFFKa5faSlCzRku1tErVVqNFazd2S83YmyAkxIjsyM69vz8ut1IJQXJuxvN+ve5LzrlnPPfKyX3u93y/z3cwkAymLVHZTEelUpGkTuHHG3tYd+cfAEpbFWaC6/8IPxzCrPHzObHzDE9jE0h0K0R8fWfUdtqSRWaGhnRt5EGvVrWwtXy5jJIQQggh8qaMWjilDmc+p0k6gyZiIGjiwKQOKrtvAANOPAng++t+3IjRzu7TyKAMqq9DGLvHl6SkFFILWJDkZk9yRUdSLE0AsLEwpUezanzQyBNrc9NXnFWInKloCScAaoQ3xtWjzkvP345LAcDaKFbRuHKy9G6lv3h7/Dkli8JnRkR4DIuuHQXgSfIhACaG36Koe6tXxvPi+iePwwAoVPjlknFCWT/9NoUBXaboO4xsY6CCJGPtrfFYS2M+sM/4M3Z8j5m4b9OOxShoYk5976GKxPicSmWI6oWBQirV293SzyvyfcKp0SSjjpkLT5cCajD2ANvv+fvxTVbcOsjV6PsA2Blb8EWlTqT+HcEU/8MkVS2Oukxhkp4PBAIKWlvQs1k13m9QGQszEz29IiGEEELo3X9aOGXQUD6niRwDT7Wz/GjM2nEwriNLjy3jduxjAEwNjGlXvBrvpbjy1957/H3uFtH/q6Tb38TIEK8KpWjs6UaL6mUxNzFO9zxC5BaH/RboWgJebN18sWB5T6fCALhZ2Sken768rsB9eoN9nv+7ddtXVKnQ7tm6CtkZ5hsrUNCa3U+SAHj0VNtf3dXiNCOftXBmhrRs5hxqjUbfIWSrTe0GsbrwagAq2drRoN6nr7wr0L7dWKVCe5mMUk8j3yecpN5BoyqGf3JPvjofz/34HQBYGppSzaQs6ltmbPszmPUJt3S7WJmbUr+SC0083KhdsZS0ZgohhBAiLZVK+3hxOR/L9wnnI3V5el6vzc047a1zc0yxf1KIe6eSOJD4ULedg60ljTzcaOzpSrWyThgb5u++GCLvCo6LYcEGbamjFwtSFyhozdNISwAKm2kHwdlZOCofoJ68Td/LZvO1LcVGKhii2g6Atb2TXqaxjAiPIS5aO2VpcWeXNOuvj1sAwISV2taguvaFFI9PZA2lpm1U2r/XjBOD24zXayyZpTIwStuHUwq/52+f3yyOpVsyRsnGJF0zIeauOTGp2ttLzkUK0NjTjcaeblQsWQQDg/z97UQIIYQQmSN1ONPK9wlnEVNbjG4V4cmVVFCreM/ZkUYerjT2dMPFsaC+wxNCcaWt7AgPf5Tuc0sOLwXgZFQcAH5DRysWV25UzebfcmiVy2pnK9PHKHSA66dWk5SqrS7w5LYtxsYWAFjYlyEmTBtnJyc3AEyMLfXSCivE67z4e/nH1tl0aD9Oj9G8hvThTCPfJ5yzq3zIgyQLEt9LoWHl0hQpIH9khRBCCPFuVAYqVAYGaZbzs3yfcBoZGNK+jru+wxAix/BqMRivDJ57nKTtbhKerF3+YcMkWrv7AFC6Uk3uXDkLQELEXexd6wLg4OiQrfFC2hHkbb8fBsD2z+a/9TGyylcff51lx3pbBw7/AMDKoIc8StKOYP5fESvKWWtfp2nkHS5ERQJwJy4BgHJWFrz3BufIjvdOiNd509bNmt9o+1SXMFOxefCb/X14K9LCmUb+fvVCCCGEENng+aChFx+gndqyYsWKLFy4UM8RKivft3AKIYQQQmQ1mdoyLUk4hRCZtrjfvDTLV//5ndKVauqWnStWAeDyoeuK3EoH7e3cF2/lvumt9OeUuh3833izy+m9SwDY+zgUgD9vqFGlap8ravqUpynaBQMV7HsSD8CtGG0fsxZFMj9laXrTd4qc7+rhTVSo31nfYWS7F7t7FDfV/n5bGip0c1duqachCacQQgghRBZTqVSoXij2rpLC70IIkTmPQ7STIYQHHgegQr2O6W7n3qCrYjEVKGjNR4tHAHA3PpUuxQoAMDiHFsBWqiXVwkxb1u09aysADM2j0ERqWzUjkzWYP2vlMVCpKGis/SAMefaJUMrcNNPnkYFC/8rxZXpekB9aNwEeXtmr/aFic5Z0ngjAvcvbFDm31OFMSxJOIYQQQogsplL9Z6YhVf5OufL3qxdCZFpEeAzTds0BIDBOW0C8+6NLfNhxoj7DAmD1wG8BGLV8DA0dy+k5GuW8qj/o8xasyN3aVun6xSO5ZattYalkbYy7jS0AxgYG2BhpPwqKmmr7bpZ91ioq3oyLdRF9hyD+48W7MBHh2n+Dnz6hihInV6n+04dTbqkLIYQQQogsJH0405KEUwjxSi9Ojbjzkbbie3SS9g+np00M+3dpR643bT1SPwG+4JtP5ujiVWo0uD68ychw54r/A6BX7EpiU7T/f9UKOFKzxSAAHt1/QInruwEY0rU3ANeObMmyWPMTzyYf6zsE8QrP/x60azf2tdse2KW9a9Kk9Yi3P6GMUk9DEk4hhBBCiCxmYGiIgaFhmuX8TBJOIUSmmBtZ0rSQ9k/GvURtH057ExNSNGpF47j6z+8AmNoUA6B05Ywm4sy7Uy6+yespWsIJgJ4l0u9rW6R4UYoU751mXfm6/3vb0EQeseQ3bZWH/l0m6zkS/Xinls1n5JZ6WpJwCiGEEEJkMSmLlJYknEKIV3remqau1J6hz/5gPokPA8DW2BITY4tMHysrWhwjn4Zoj5HBH+/nx85pM+DMW/cFACYGKoZ0nabnaIR4NX21bKZ33ebaOxQqVdqR6dLCKYQQQgghspK0cKYlCacQQgghRBYzMDDEwMAwzXJ+preE8/bt24waNQpTU1M2bNgAwM2bN5k1axaurq48fvyYuXPnYmRkxOPHjxk/fjyurq7cvXuXuXPnYmVlxdOnTxk9ejQlS5bk5s2bzJw5kyJFpPCuENnB3qEA9o0/AiD41g0A1MmJlCpfKVP7v3ir7E1KFl0+tIE/7p4H4MbTBJo6aKdsrFOg7Cv3y2m34SKSkwBIUGv0HIkQOc/zvw+hAUcYcnwXT7WzsOJbxom6dQfluOs5U+SWehp6a989ceIE3t7eadYNHDiQoUOHMn78eExMTFizZg0A48ePp23btvj6+lK5cmXmzNHOdvLtt99Svnx5fH196dSpE59//rnir0MIIYQQ4r+0o9QNXni8WcJ5+/ZtOnToQNeuXbMpQmXpLeHs1q0bpqamuuWkpCSOHj2Kh4cHAF5eXuzatQsAPz8/atasmen1Qoi398lPIzi7fxln9y/LcJsSrmUp4Vo2062b//UmrRWmloW58TSBG08TOBKeyqXoGC5Fx1CmZgvK1GzxVufXh+m9vmJ6r69oV9RJ36EIobjui4ZT6euhVPp66Cu363poF6ePJ3H5TDKXzyQz4tI9UpISiAiPyXEDAV8rTbJp8MaF39NrmMvNckwfzrCwMCws/h3tamNjQ2hoKAChoaFYW1u/dn1YWBhqtRoDg5f/UxMTE0lMTNQtP3nyBICrV69mzwsS+dbz36n4+Hg9R5J5Go32Nm90dDRJ8YnEPo3XLWeV6Oh/PywMjTJ/Wzkm9ilJ8dprV52gJjFeleWxKenp04RcG/vbeP5an/+O5QYvXg8iayTHJ5KakPH7+vzvQ2pCEprkJDRq7XWuTtAQExODobG2S8qb/O3Iam/6uxwbG4dKZZhm+cXjPGdqapqmAe65bt26sXLlyreMNufJMQmnvb09cXFxuuXo6GgcHBwAcHBwICYmBisrq3TXP9/e3t4+3WQTYNasWUydOvWl9T169MjqlyIEAHfu3KFu3br6DiNTnl9HJUqUAGCt7pnP9BLPq3z//N/BC/Qax7t5/dR6eU1MTAy2trb6DiNT/ns9iKxlO/mnTG8bDbhOy/z2Snjd77KJiQmOjo5Uqlz+peesrKxe+r2aPHkyU6ZMyeowc5wck3CamJhQp04dzp8/j4eHB8ePH6d169YAeHt7c/LkSdq3b5/u+tq1a6dZnx5fX19Gjvx3ruc7d+7g4eHB7t27KVSo0BvF2qlTJzZv3vwWrzLjfWNjY2nYsCF///03VlZWWXbOt93vdfFkxznf9r3JjnO+yuviiY+P586dO7Rs2fKN49GXYsWKERwcjLW1db6fDUNkLY1G20JVrFgxfYeSaXI9iPRk9nfZzMyMwMBAkpKS0j3Gf3+n0mvdzItUGj3d59i5cyfLly8nICCAvn37MnToUG7evMmMGTMoXbo0T5484ZtvvtGNUvf19cXZ2Zng4GDmzZunG6U+atQonJycuH37NjNnzsTR0TFT54+OjsbW1paoqChsbGzeKPaKFSty5cqVt3nZGe77unje9pxvu58+3p+3fW+y45yv8i7vjRBCCJFZK1euxM/PT1fNJzfTWwtnmzZtaNOmTZp1bm5urFix4qVtCxcuzLJlLw9gsLS0ZPHixdkWY0YGDx6s+L5K7/cu9BFrbnp/hBBCiNfZuXMn27dvJyAggAULFjB06KsHXOV0emvh1Lec1kol8eSOWHJiPEIIIUROl2/nWTI1NWXy5Mk5pu+ExJM7YoGcF48QQgiR0+XbFk4hhBBCCKGMfNvCKYQQQgghlCEJpxBCCCGEyFaScAohhBBCiGyVYwq/v62dO3fi5+eHpaUlzs7ODBw4MM3zN2/eZNasWbi6uvL48WPmzp2rq+05fvx4XF1duXv3LnPnztXV9hw9ejQlS5bk5s2bzJw5kyJFipCamsrnn3+Ovb09t27d4vPPP6dcuXLZGsvEiRNJTk7Gzs6Oixcv8t1331G4cGHu3LmDt7e3ruZou3bt0hS1z654Vq5cyeLFizEzMwNg0qRJNGnSJFPvTXbE07dvX27evKnb/+LFi9y/f5+HDx9m6/uTlJTE999/z8SJE4mIiNC9H696H6ZPn05qaiohISF8/PHH1K5d+6V4hBBCiDxLk4vFxMRoypQpo0lOTtZoNBqNl5eX5ubNm2m2adq0qebcuXMajUajGTNmjGb58uUajUaj6dOnj2bLli0ajUajWbhwoWbSpEkajUajmT59uua7777TaDQazc6dOzUfffSRRqPRaNasWaMZPny4RqPRaC5fvqxp0KBBtscyceJE3b5fffWV7vyBgYGaFStWKP7erFixQhMYGPjSuV733mRXPL/99ptu36CgIE3fvn0VeX8OHz6suXnzpgbQxMfHv/Z9OHz4sOZ///ufRqPRaCIiIjTlypXTpKamvjI+IYQQIi/J1bfUjx8/jouLC0ZG2obaGjVq4Ofnp3s+KSmJo0eP4uHhAYCXlxe7du0CwM/Pj5o1a77V+ooVK3Lu3DmePn2arbFMnz5dt39qamqaaRS3b9/OnDlz+OKLLwgKClLkvQFYuHAhc+fOZdasWcTFxWXqvcmueN5//33d/osWLWLQoEGKvD/16tXD1dX1pWNm9D68uN7Ozg4TExOuXr360v5CCCFEXpWrb6mHhoZibW2tW7axsSE0NFS3HBYWhoWFRbrPv7jvq9aHhYWhVqtfOpe1tTWhoaFYWlpmWyzPRUdHs2/fPjZt2gSAg4MD06dPp2LFily9epWWLVty5cqVNPOzZkc8DRs2xMfHh0KFCvHTTz8xbNgwfv7559e+N9n9/iQkJHDlyhWqVq2qyPuTkYzeh9DQ0DRTrmbmWEIIIURekqtbOB0cHIiJidEtR0dH4+DgoFu2t7fXtcL99/kX933Vent7ewwMDF46V0xMTJpzZUcsALGxsXz22WcsXbqUAgUKANopPStWrAhAhQoViIiI4P79+9n+3ri4uFCoUCFAm3wePHgw3XP9973JzvcHYMOGDXTt2lW3nN3vT0Yyeh9edy4hhBAir8vVCaeXlxeBgYGkpKQA4O/vj7e3N0FBQajVakxMTKhTpw7nz58HtLdRW7duDYC3tzcnT558q/VXrlzB09MzTQtedsQSFRXFkCFDmDFjBi4uLmzcuBGA1atXc+nSJQAiIiJISUmhcOHC2f7ejB8/Xne8W7du4ebmlqn3JrvieW7z5s106tRJt5zd709GMnofXlwfGRlJUlISFSpUeOWxhBBCiLwk1880tGPHDnbt2oWlpSWurq4MHDiQ6tWrs3TpUjw9Pbl58yYzZsygdOnSPHnyhG+++UY38tnX1xdnZ2eCg4OZN2+ebpT6qFGjcHJy4vbt28ycORNHR0dSU1MZM2YMdnZ2BAYGMm7cuJdGYmd1LI0bNyY0NFTXqmhlZcWOHTs4cOAAP/30E56enly9epUuXbrg4+OT7e/N/PnzuXz5MqVKleLixYtMmzaNsmXLZuq9yY54AI4ePcq+ffuYNGmS7jzZ/f4EBwezatUqvvjiCyZPnkzv3r1xdnZ+5fswffp0kpKSePDgAX369JFR6kIIIfKVXJ9wCiGEEEKInC1X31IXQgghhBA5nyScQgghhBAiW0nCKYQQQgghspUknEIIIYQQIltJwimEEEIIIbJVrkk4g4KCsLOzw8DAAJVKlWbWGCGEEPlbYGAg3bt3x8nJCXNzcwoVKkStWrVemmZXCKEfua4skrOzM3fv3gUgl4UuhBAiG6SkpPDee+9x/fp1SpQowblz54iIiOC9997jwYMH2NnZ6TtEIfK9XD2XuhBCCHHt2jWuX78OQJ06dShYsCAFCxbkwoUL2NjY6Dk6IQRIwimEECKXe/Lkie5nMzMz3c9lypTRRzhCiHTk6D6c3333HeXKlcPExARnZ2cmT54st9FFvrZnzx5atGhBgQIFsLCwoEyZMkyYMIGEhAR9hyaEXsyePTvN1LXr1q3Dzs6OypUr6zEqIcR/5diE84svvmDEiBHcuHGDuXPncvPmTczMzAgKCtJ3aELoxdKlS/H29mbv3r38/PPPPH78GAsLC2bOnImPjw9qtVrfIQqhuHHjxrFjxw7dcvfu3YmMjOTChQt6jEoI8V85MuEMDw9nzpw5AJiamvLpp59iZGTE0KFDMTQ01HN0QigvJiaGUaNGodFosLKyomPHjlhZWdGlSxcA9u/fz9atW/UcpRBCCJG+HJlwnjhxgsTERAAcHR0xMtJ2NbW0tKRgwYL6DE0IvTh69CjR0dEAFCpUCAMD7aVbpEgR3TZ//vmnXmITQgghXidHDhoKCwvT/WxqaprmOQsLiyw91+3btxk1ahSmpqZs2LDhnY7VtWtX3N3diY+PJzg4mGXLlmFiYpJFkYr87MVBEc9r0gKkpqbqrpFHjx6983my8np4/PgxEyZM4NKlSxw7duydYxNCCJF75cgWTnt7e93Pz1s6n4uLi8vSc504cQJvb+8sOVatWrX44osvmDlzJuHh4dLiJLLMi9dE8eLFiYyMJDIykpiYGBISEkhISMiSW+pZeT0cOXKEtm3bykA/IYQQOTPhrFWrlq7V5uHDh6SkpADw9OlTwsPDs/Rc3bp1e6kVdePGjQwePJgZM2YwZsyYTH9gjhgxAoDk5GRCQkJwc3PL0lhF/lW7dm1d6/7Dhw+JjY1N83yrVq3YtGnTO58nK6+HDh06SA1EIYQQQA5NOAsWLMiYMWMAbQvn4sWLSU1NZcGCBaSmpmbrucPDwxk5ciTfffcdEyZM4MmTJ+zcuROA6tWr4+np+dIjJCREt/+ff/5Ju3bt6NSpE+7u7tkaq8g/bG1tmTFjBqD9QjNx4kTi4+NJTExk8uTJXL58mSZNmmT5ed/1ehBCCCEgh/bhBJg+fTr29vb8+OOPjBgxgq+//pqPPvqIkiVL6koj2dnZsWPHDurVq5dl57116xYajYZvvvkGACMjI91gjVOnTr12/1atWtGqVSv69u3LokWLGDRoUJbFJvK34cOHU6pUKebPn8/y5cv5+eefcXR0pEmTJhw+fDhbBtS96/UgRHZbt24d/fv3T7O8ZcsWfvzxR7p3767HyIQQL8qxCSdoP2CHDx+eZt2XX36Zred0c3PDzMyMzz//HAMDA06fPo25uflr9wsNDeXkyZO0adMGAFdXV27dupWtsYr8p0OHDnTo0EGx873t9SCEUrp37y6JpRC5gEqTz3v079y5k+XLlxMQEEDfvn0ZOnQov//+OwcOHKB48eI8ePCAWbNmYWlp+crjREREMGTIENzd3UlMTOTKlSssWLCAokWLKvRKhHh3WXU9APzzzz+sWLGCPXv2MGDAACZMmIBKpVLgVQghhMhp8n3CKYQQQgghsleOHDQkhBBCCCHyDkk4hRBCCCFEtsrRg4ayk1qtJiQkBGtra+lXJrKURqMhJiaGYsWK6aagzOnkehDZRa4HIbRy47WQlfJtwhkSEkKJEiX0HYbIw4KDg3FyctJ3GJki14PIbnI9CKGVm66FrJRvE05ra2tA+x8vs6GIrBQdHU2JEiV0v2O5gVwPIrvI9SCEVm68FrJSvk04n98msbGxkT8oIlvkpltxcj2I7CbXgxBauelayEr5rxOBEEIIIYRQlCScQgghhBAiW0nCKYQQQgghslW+7cMpRG5z+/ZtRo0ahampKRs2bMhwu/79+3PhwgWOHz+uYHRCKOt118Pjx48ZP348rq6u3L17l7lz52JlZfXW5wuKiuLOpQcEb7hOXHAMFiWsKdG1HM7vFaWkre27vBQh8gVp4RQilzhx4gTe3t6v3GbDhg2YmpoqFJEQ+vO662H8+PG0bdsWX19fKleuzJw5c976XEFRUXT+eAH76//K8X9OsanFOY7/c4r99X+l8ycLCIqKeutjC5FfKNbCuXr16tdu4+DgQKtWrRSIRojcp1u3bqxcuTLD52/dusWZM2fo1KkT/v7+ygUmhB687nrw8/Nj+vTpAHh5eTFgwACmTp36Vue6c+kBrbaoUWk03OqZQFxJNbd6JlDwnCWt/lBzd9QDStaRVk4hXkWxhHPmzJnUrl37lduEh4dLwinEW0hKSmLatGksXryYEydOvHb7xMREEhMTdcvR0dHZGZ4QigsNDdXVO7SxsSE0NDTDbV93PQRvuA5AeJUUYsqmAhBTNpWIKikUOGdM0PrrUKd8Vr8EIfIUxRLOxo0bs2jRolduM2LECIWiESJvOXr0KDY2NsyfP5/bt28TEhLC7NmzGTRoELbp9C+bNWvWW7f2CJEbODg4EBMTg5WVFdHR0Tg4OGS47euuh7jgGDRouDIkHjSAClDDzR6JVD9nRFxwTNa/ACHyGMX6cM6ePfu128gHoBBvJiQkhKSkJBo1asT333/PuHHj6N69O8WKFWPcuHHpJpsAvr6+REVF6R7BwcEKRy5E1nt+PQB4e3tz8uRJAI4fP07r1q0z3O9114NFCWvCq6SQWFijTTYBDLStnOFVUrAokT9njhHiTSiWcKb3wadWq9PcupAZHYTI2M6dO9m+fTtXrlxhwYIFAAwePJg9e/botjlz5gxr1qzh/v37zJs3L8NjmZqa6mZRkdlURG70uuth5syZbNu2jenTp3Pu3DnGjBmT4bFedz04fVCW2x8mgvo/O2rg9oeJlOhaNktfmxB5kUqj0WiUPOHo0aNxcHBg+PDh1KhRgwcPHjBu3DhGjRqlZBhER0dja2tLVFSUfNiKLJUbf7dyY8wid8iNv1v/jflWRBi99s1EZZ7Ox+VTFStbjMe1gL3ygYpcJTdeC1lJ8bJIcXFxjB07lt9//53SpUsTGhrK1atXlQ5DCCGEyBTXAvZ833AYg2060uloVQrc+bf0mL2fKZcfZTwgSQihpXjh9+eFd3/77Tf69+8PQIECBZQOQwghhMi0KoVLUqVwSWhQj0aPbvKZ/48AxHslMfvrrTT40Rk7MzM9RylEzqV4C+eDBw/w8fHh/PnztGzZkgMHDnDlyhWlwxBCCCHeimcRN8qpiwIQV1xN6UfRjNrpp+eoxLs6duwYKpWKTz75JM36Dh06oFKpOHPmjJ4iyxsUb+FcsmQJfn5+VK9eHUNDQ+Lj45k8ebLSYQghhBBvbWDt9ow4sRiAJ60TiVh+jhuN6lPWXvpyZoegqCiexMW9tL6QhUWWTS16+vRpqlWrxqVLl3Tr9u3bR1BQECYmJrz33ntZcp78KtsTzoSEBAwMDDAxMQHA3NwcLy8vihbVfjts06ZNdofwxqovWcLD2Fi9nNvRyopTz7oaCJETLKm+hNiHyl8PVo5W9D8l14LImaoVKkNZo2LcSAnhaSk1tZJVlDSy1HdYeVJQVBTlfviBhJSUl54zMzLi+pAhWZJ0njlzhg8++IC5c+ei0WhITU1l9OjRfPzxx6xevVqXx2TG1q1badGiBebm5u8cV16RrQnnt99+y/bt2zEyMsLV1ZV58+Zhbm7Ohx9+yIEDB7Lz1O/kYWws92OkkK8QALEPY4m5L9eDEC9SqVT0q9qGMSd/BuBmmxgOzzpM89nN9RxZ3vMkLi7dZBMgISWFJ3FxWZJwnj59mp49e1K6dGlu377Nzp07qV+/PgkJCVStWvWNjrV8+XLatWv3zjHlJdmacG7evJl//vkHgL1799K2bdvXzjaUkxioVBR9Nsgpuz2IjUWtbIUqId6IykCFVdHsvx5iH8SiUcu1IHK+Wg7lcTMrys2EB8S4qtnx62Fq3K2BXSk7fYeW68w7dox5x46l+1xSauor9x3u58ftiIh0nxtZuzYjXzOtNmjvxl69epUqVarg6enJwYMHWbBgASdPnmTQoEE0btyY1NRU6tevj4uLC6dOnWLr1q2UL1+er7/+Gj8/bR/eLVu2sHv3bo4ePUrjxo1ZuHAh7u7urz1/fpCtCWdqaiopKSkYGRnRvHlzKlSowMcff8yNGzey87RZpqiVFfdGjlTkXE7z5kmrqsjRrIpaMfJe9l8P85zmSYuqyBVUKhUfv+fNhFMrALjZMZ69vvsIH+lMj8qVsXyDW7D5XXRi4lt/BkYmJGS4b3RiYqaOceHCBUqUKIGdnR2enp6MGjWKmTNnUrBgQc6cOcOoUaO4efMmhoaGrFq1inXr1uHv709ERAQPHz7kwIED/Prrr2zbto2OHTvi7e3NmjVr3ur15FXZmnDOnTuXJ0+e4OjoCICTkxM7d+5k3bp12XlaIYQQQhH1irjjYuFIYNxDosun8s+a82xacplrHZ/wrbe3vsPLNWxMTSlunf4UoUmpqYSmM2DoOTszswz3tTE1TXf9f505c0Z329zb25vY2FgGDhxIdHQ0QUFBVK5cGT8/P7p3746RkRHh4eFUq1aN7du3c/jwYRo1akRCQgKjR4/m8uXL0qqZjmxNOOvWrfvSOhMTE3r37p1m3fXr1ylXrlx2hiJEjnTixAlq1aql7zCEEG/JQGVAr/LNmXJG25p1u2sCLRdbMb/YCd53d6dOiRJ6jjB3eNWt7zMPHlBtyZIM9/3O25uqzwYiv63Tp0/rEs5SpUrpZj88e/Ys5cuXx8zMjCtXrtCoUSMALl68SM+ePVm/fj1r166lbNmyJCcnY2xszOrVqylTpsw7xZMXKV4WSa1Wc/DgQR48eIBarZ2Y9pdffkkzH7QQeVFUVBSbNm1K87u/a9cujh8/rufIhBDvolFRD0pY+BEcF0pkpVRcrVIod82IT7Zu5eyAAZgbG+s7xFytkIUFZkZGGY5SL2Rh8c7n+Pnnn9Nd37BhQ86fPw/AtWvXGDJkCACPHz/G3t6e/v3706tXL8zMzChfvjyLFi2ifPny9O3bl8ePHzNo0KB3ji2vUDzhbNeuHVFRUbi6uqJSqQC4f/++0mEIoTgfHx+cnJwoU6YMhoaGAGhkoJgQuZ6hyoCPyjZjxrn1FDxrhFG8iuZ74ccyYUz9+29mN2um7xBztZK2tlwfMiTb63C+zurVq3U/b9++HQBPT0+O/WewU82aNblw4YIiMeUmiieckZGRupHrz/35559KhyGE4oyMjFi/fn2ada1atdJTNEKIrNSsWFVKWhbmxNcHCAoMAqDaaZhjfJROFSpQo3hxPUeYu5W0tVUssRTZQ/GpLRs2bMitW7fSrLt586bSYQihuEaNGhEQEJBm3YkTJ/QUjRAiKxkZGFKxQClafNNCt67RX2ASp+GTbdtIzKCOpBD5heIJZ40aNahSpQrFixendOnSuLi48MUXXygdhhCKW7lyJe+995787guRhxWvUZxK3SsBYBEP9Q/DpcePmXn4sJ4jE0K/FL+l7uvry5YtWyhdujQqlQqNRsOUKVOUDkMIxTk5OfHXX3/pluV3X4i8qfGMxvx15xyRLsnU2mCGfw2Y+c8/dKxQAY9nZQKFyG8UTzgrVapEkyZN0qyTVh6RH+zatQvr/9SK+/LLL/UUjRAiu3z56DfO+saCGoocMqbpfkOKfV0d14IF9R2aEHqjeMJZsmRJPv74Y+rUqYPps4KsUhZJ5GXh4eEULFiQs2fPvvTc/Pnz2bx5sx6iEkJkl+qFynIy9DoYwMPGyVRabUifgpWwkpmHRD6meMK5fv16WrRowdGjR3XrpCySyMvq1KnDnj176N69O2XLlk1TCkkGzAmR97QvVYfTTwJwv+zA3dXaGo57R++l96HeunKAQuQ3iiec48ePZ/DgwWnWPa9nJURedO3aNUDbdWTAgAFpnvvpp5/0EZIQud7OnTvx8/PD0tISZ2dnBg4cmOb53bt3s3nzZlxcXLh//z7z5s3DRKEWRgsjU+bW6k9q1VQWfX2fsOthBP0TxLU/rlGhYwWCoqIoZm2NkYHi43aF0BvFEs5BgwbRrl07+vXr99Jzbdu2fadjz5kzh7t372JhYUFSUhLffvutfIsUOc5/k02AEjLtnRBvLDY2lhEjRnDlyhWMjIyoXbs2zZs3x9XVFYDU1FR69uxJQEAAtra2DB06lBUrVqR7DWYnQ2NDmn/dnA3tNwCwb+w+9hWJwvfvA0xp1IjRdeooGo8Q+qRYwtmhQwe2b9/O6NGjKVeuHG3btsXHxwcHB4d3Om5ERASzZ88mNDQUAwMD3N3duXDhAh4eHlkUuRBZIy4ujh9++IGAgABSU1MBbR3O1q1bZ2r/27dvM2rUKExNTdmwYcNLz/fr14/ixYtjYGBAYGAgCxcuxCILpnwTIqc5fvw4Li4uGBlpP8Jq1KiBn5+f7u5ZeHg4KSkp2D4rFF6qVCkOHjyYYcKZmJhIYmKibjk6OjrLYi3btiylGpbi+pVAwm+G4/flbp56wRcHD9KuXDnK2ttn2bmEyMkUa89v0aIF33//PZcvX2bKlCncv3+fdu3aUa9ePWbPns3ly5ff6rimpqaYmZkRGxtLSkoKZmZm6bYaJSYmEh0dneYhhJKGDBmCgYEBQUFBNGzYEBcXF12LTGacOHECb2/vDJ93dHRkypQpTJo0CXNz8wznBhYitwsNDU1T8cHGxobQ0FDdsoODAw4ODrqJFk6fPv3Kv/mzZs3C1tZW98jKOw8XIwI5OT6Ko4tjSCyopsURI8ziISElhU+2bkUt09tmWlhAGPt897G522b2+e4jLCAsW85z6tQpDAwM+O6777Ll+PmVXjqQVK5cmYkTJ3Ls2DE2bdpEoUKF8PX15fvvv3/jY1lYWDBz5ky6devGhx9+SIsWLXTfal+UnX9QhMgMBwcHRo8eTYUKFejVqxdffPEFFSpUyPT+3bp101V2SM/06dN1P6empmJlZZXhtvIFTOjbvHnzmDt3Lmq1mlatWmFvb8+6desyta+DgwMxMTG65ejo6Jfulu3YsYPly5czf/58SpUqRcmSJTM8nq+vL1FRUbpHcHDw272odPzz8DIXk+6iNoG7HRIxiEmh7UntdXwkOJiFJ09m2bnysrMrzrKw/EKOzjnK5d8uc3TOURaWX8i5leey9DwajYbPPvuMJk2acO5c1h47v1M84VyyZEmaZUdHR/r27cu2bdv47LPP3vh4Z8+e5bvvvmP79u38+uuvBAQEsHz58pe2y84/KEJkRlRUFACRkZE8evSI+Ph4TmbDh01wcDB37tyhZ8+eGW4jX8CEvl2+fJmRI0eyY8cOEhISCAwMxM/PL1P7enl5ERgYSMqz6SL9/f3x9vYmKCgItVoNQExMDLNmzWLYsGEAfPjhhxkez9TUFBsbmzSPrNLVtREmBtpb//daJZFko+a9I8kUCNc+P27/fm5HRGTZ+fKisIAwtvfdjkatQZOqSfPvtj7bCL8ZnmXnWr16Nba2towbN04Sziym+Cj1adOmvdT/zMTEBE9PT8aPH//GF/r9+/cpVKgQBs9G+zk6OhIfH//Sdqampq9sHRIiu9nZ2bFhwwY++OADnJ2dAe1guqz08OFDxo8fz/r16185ItfX15eRI0fqlqOjoyXpFIoqXLgwBgYGbNq0iU8//RQbGxscMzkLj5WVFfPmzWPo0KFYWlrSq1cvXF1dqV69OkuXLsXT05Mff/wRS0tLihYtirOzM/Xr18/mV5S+gqbWtCtZm013DqM2haD/JeG22oABZwswu2kEccnJ9N22jf0ffZRvB7suqb6E2IexGT6fGJWIRp1+1wONWsNPVX7C1Dbjz3crRyv6n+r/2jhiYmKYNGkSe/bswc7OjitXrpCUlKRYdYO8TvGEs02bNjg6OlK3bl0Ajh07RmxsLCVLlmTo0KGsXLnyjY7n7e3Njh07+Pzzz7GwsCA6Opo+ffpkQ+RCvJvu3btjb29P8eLFCQgIICoqCnd393c6ZkhICIUKFcLExIR79+4xceJEfvjhB2xtbdm4cSPvv/9+uvvJFzChb7du3WLIkCHs37+fn3/+matXr+pKiGWGj48PPj4+adadOnVK9/PSpUuzLNZ31c21MVuDjpKsTiW4bRKlfjfB7HAE1atacqrAUw7eucOS06cZUL26vkPVi9iHscTcj3n9hhlIik0iKTbpneOYNm0a77//PuXKlQPQJZ2enp4A/PDDD/z2228kJSWxa9cuCsrMUW9E8YTT1NSUqVOn6pZbtGjBwIED+fTTT3UdvN+EkZERixcvzsoQhcgW9erVY926dRQvXhwnJyecnJzeaP+dO3eyfft2AgICWLBgAUOHDmXw4MH06dMHHx8f6tevj729Pe3btwfAzc0tw4RTCH1buHAhv/zyCzt27MDU1JR//vmH/v1f3wqVGxU2t6O1U022Bh0j1UxDUNskXNeb0e2wBafaPgUVjNm7l1ZlylAynTEIeZ2VY8b9zUHbwvmqhNLEyuS1LZyvc+PGDX788UcKFizIpk2bAG2L57lz5/D09OTkyZOcP3+eQ4cOkZKSoquQIDJP8Xfs/PnzJCQkYGZmBkB8fPwbfasVIrdq0qTJSy0yR48epU4ma/G1adOGNm3apFn3xx9/6H4ODAx89yCFUIiDgwMjRozQLffr149du3bpMaLs9aFbU3YEnyBVo+be/5IptcWUmDOhDGnmzA8Wd7AzM+NBTEy+TDhfd7s7LCCMheUXpntbXWWgYsDZARR0e7fWxuHDhzNv3rw0pbNGjx6t68f5xx9/MHz4cABJNt+S4u9ahw4dKFmyJNWf3To4ffo0kyZN4sCBAzx48EDpcIRQTJUqVfj8889p3ry57nb2/PnzM51wCpGX3L17l6VLl/LgwQPdQJ83qUub2xS1KEiL4tX4854/yRZqgtsk4rLJDNeNkXz+gxcTmjbCRrq5pMu+jD3tlrVjW59toAI06P5tt6zdOyeb27dvJygoiL59+6ZZ7+7uzqpVqwDtoM/n9ZOlhfPtKP6OVapUiX379vHXX3+hUqn46quv2LdvH02aNKFJkyZKhyOEYubPn4+Hhwf+/v66dTKXusivOnToQMuWLalTpw6GhoYAeb56SA+3puy+dwo1Gu6/n0LJ7RqiAiP533UbbFpLsvkqnr09KVmvJGeWnSHqThS2zrZU7VP1nZNN0M52mN6Mhx9//DEff/wxoG2B79OnDxYWFnz22Wd07tz5nc+b3yiecC5cuJDff/+dypUrA7BlyxZmz56d5taKEHnR4MGD09TKBN54kJwQeUWhQoWYNWtWmnXPB5PmVSWtCtOkmCf7Qs6SYJHKvVZJlNpiyqHph/Ds5Yl5QXNAWwsSyLej1jNS0K0gzWY108u5q1SpkqaxQLw5xetwBgUF8eWXXxITE0OvXr0YP348lSpVUjoMIRT332QToHfv3soHIkQO0LFjRw4ePEhycrJu3dq1a/UYkTJ6uv2bMIV0V5NqrCEhIoFDMw4BEBQVhffatWy4dElfIQqRLRRv4dy9ezfHjx+nXLlydO7cmTNnzvDo0SOlwxBCCKFHn376qe5nlUqFRqNBpVIxefJkPUaV/UrbFKWhYyX+fniRp+ZJPGxtTPGtRpz8/iTFepSjjt96YpOSOB0SQhMXF4q8YsYwIXITxVo4Dx06xKFDh7h8+TLW1tZ06dKFQoUKcfLkyTQFqIUQQuR9Pj4+qNVq1Go1qampqNVqxo0bp++wFNGzTHPdz/d7pqI20qBOVnNtlj+t3NwACIuP57M//9RXiEJkOcVaOLt160a5cuV0fVOeO3jwoAycEEKIfGbbtm0AxMXFAWBhYcGMGTP0GZJiytk6UbtwRY49vkK0aQLh7Uwp9Dtc2XiFiQO6ccA8kLD4eDZeucLmK1foVLGivkMW4p0p1sI5ceJEDhw4wMGDB196pNe3TYi85unTp0yYMIEhQ4YQFxfH9OnTSUxM1HdYQuhFcHAwDRs2xMrKCmtraxo1apTnR6m/qFeZf/tyBvdMRW2gbYzxn3iYBd7euuc+3bWLsGdJuRC5mWIJ56vmjJaBEyI/GD58OAYGBjx+/BgLCws8PDykO4nItz7//HOGDBlCSEgI9+/f59NPP+Xzzz/Xd1iKcS/gTPVCZQEIN3oKrbR9Ne8dv4fHNUPaP5te8fHTpwzfvVtvcQqRVRRLOHdn4oLZv3+/ApEIoR8FCxZk+vTp2NvbA9CuXTssLCz0HJUQ+lGyZEnef/99HB0dcXR0pEuXLhQrVkzfYSmqV5nmtChejdUNP+fDQe106/eN28f3zVpi92xGvl8uXGDHjRv6ClOILKFYwrl169bXbrNz504FIhFCP573VXteW0+tVnP37l19hiSE3ty7dy9NSaSkpCRCQkL0GJHyPO1d+aLKhzhbF6FM6zK4NHUBIDIwknurr/Fty5a6bQfs2EFkQoK+QhXinSmWcC5evBhDQ8NXPo4fP65UOEIormzZsjRr1oyjR48yYMAAKlSoQMOGDfUdlhB60aFDB5ydnWndujWtW7emdOnSvP/++/oOS29UKhUt5rbQTtkIHJp+iPedyuD9bNR6SEwMm69c0WOEQrwbxUapP58rV4j86rPPPqNixYr4+fkB2i9hjRs31nNUQuhH586dqVy5Mnv37gXgu+++o2zZsnqOSr8KVXbAZUA5AhdfJyEygcMzDrNkig8tf/mFr5s3xyefvz9KS0pKolChQoSGhmIq89y/M5l9XgiFjBgxgm+//ZamTZvqOxQh9C4hIYFixYoxePBgbt68ydWrVyldujRGRvnvYylVo2Zn0Al+ubUf6/fNcFllSGp8Kv4L/ak5uCaXPv0UA5nmEoBToTf47vIfDHfvQHWH7E3Az507R5kyZSTZzCKKT20pRH519OhRevTowezZs3n48KG+wxFCr7p3786aNWsIDQ2ldu3arFix4pXVTPIyA1T8cfcID+LCuREXQuFp2tvo6mQ1+8btk2TzGY1Gw0/XdnI39hE/Xdv5Ul3vdxUeHs6HH37Ie++9R+PGjdm+fTs1atTI0nPkZ/nvq6QQerJq1SrKly/PpUuXmDNnDpGRkXTs2JE2bdroOzQhFOfm5sagQYNYsGAB3bt3Z/78+QwfPlzfYemFSqXiI7fmTDqzipoO5ahTtSZ+c+/x9NFTrm6+StCRIErWLQlok661Fy9S0taWBqVK6TnyrLPh9l/8dvvvV26TlJpMVLJ28OW1qGDa7vkCE0PjNNt84fkhVQq5vVUMHTt2pEuXLqxdu5b79+9TpkwZFixY8FbHEi/LEQlnQEAAZcqU0XcYQmQrY2PtH8bChQvj4ODA1q1bOX36tCScIl96+vQpGo2GX375hUWLFgFv1td/586d+Pn5YWlpibOzMwMHDkzz/J49e1i1ahUVK1bkzJkzLF26lAIFCmTpa8hKDYtWYmn9kZSzdQIgcVpjdgzYAcCeUXvoc6wPMUlJfPj77+y4cYPSBQpwYeBALE1M9Bl2lolLTiA0IeqN9olKjoPktOuS1Clvdf6DBw8SExPDp59+CkDx4sUpUKCAtHBmIb0knP7+/ty4cYPU1FQAfvnlF/bs2aOPUIRQTL9+/bCzs+Pvv/+mc+fOrFu3jpo1a+o7LCH0wsHBATs7O2rWrEm1atWYM2cOt2/fztS+sbGxjBgxgitXrmBkZETt2rVp3rw5rq6uum0+//xzVq5ciaenJ4MHD2b16tUMGzYsu17OOzNQGeiSTYAqn1ThxIIThF4O5f6J+1z+7TIVu7jrSiPdjohg4oEDfPvCrES5mYWxGQ5mthk+/2Lr5otsjS3StHKaGLxdWnPmzJk0f4/v3r1LREQE7u7ub3U88TLFE84pU6Zw6tQp7ty5Q40aNQgKCiIyMlLpMIRQXHBwMD169GDNmjVYWlrqOxwh9GrKlCkMGzYMOzs7AHr27Em/fv0yte/x48dxcXHRDTCqUaMGfn5+DB48WLdNkSJFePLkCQBRUVFUrlw5a19ANjMwMqD5nOasa70OgP3j9lO+fXmWt2tH5cWLSUhJYf6JE3SuWJG6JUvqOdp317V0I7qWbpTucxqNhv7/fEd0VDwa/u23qUJFUQt7ltQbrqtv/LYcHBz4/fffSUlJISUlhUGDBuHp6ZkvB7FlF8UHDYWFhbFjxw6aN2/OihUr2L9/P02aNFE6DCEUt3LlSj755JM0yeaFCxf0GJEQ+lWgQAFdouDo6MiMGTMytV9oaCjW1ta6ZRsbG0JDQ9Ns89VXXzFt2jQ+++wznj59SqVKlTI8XmJiItHR0Wke+qTWqDn08CJ7Sl2ldLPSAETeieTkDycpY2/Pl8/KqWmAT7ZtIz45+RVHy/2S1ak8io9Ik2wCaNDwOCGSZHXqO5+jS5cu2NnZUaFCBZo2bYpKpaJ69ervfFzxL8VTd7NnU3W9eEHLbCsiL7t48SLu7u7cunWLW7dupXlOupOI/KZBgwasXbuWUqVKpWmV0mg0qFQq5syZ89pjODg4EBMTo1uOjo6m3LO5x0FbP9HHx4dTp07h6OjIDz/8wLBhw1i7dm26x5s1axZTp059h1eVtXz9l3P0sbbI+1czP+L2/tuggUNfHsLzY0+Ge3nx25UrnLx/nxthYUz56y++at5cz1FnHxNDI36uP4LIpKcvPVfAxAoTw3dPZczMzGS2w2ymeAvntWvX2Lx5M5UqVcLDw4MGDRro/dukENnps88+4/79+8yePZuDBw+medy/fz/Tx7l9+zYdOnSga9eu6T7/+PFj+vbty6xZsxg4cCCxsbFZ9RKEyDKLFi3CycmJkSNHkpqaqnuo1WpGjBiRqWN4eXkRGBhISop2gIi/vz/e3t4EBQWhVqtJTEwkMjISe3t7QNt6Gh8fn+HxfH19iYqK0j2Cg4Pf/YW+A6/CFXQ/71SdxbO3JwCJUYn8Pe1vDA0MWNG+PSaGhgDMPXYM/zf4W5IbFTEvQDlbp5cehc3t9B2ayCTFWziXL1+Ovb09BgYGODo6EhYWRs+ePZUOQwjF/PXXXwBMmzaNzp07p3lu06ZNmT7OiRMn8Pb25uDBg+k+P378eNq2bUv79u358ccfmTNnTo5qtREC0A3CUKvVbNy4Mc10lnPnzs3UMaysrJg3bx5Dhw7F0tKSXr164erqSvXq1Vm6dCmenp58/fXXDBgwADc3N86fP//K2/WmpqY5qrh36xI1WRWwl7DEaA49vMgH4wdx+dfLJMclc+rHU9QcUpOKZRyY3LAhEw4cQK3R8PHWrZzu3x9T6XMocijFWjiPHTtG0aJFcXR0pEqVKty7d4+uXbsyePBgbGxslApDCL15+jTt7aBly5Zx6tSpTO/frVu3V34o+vn56UZZenl5sWvXrgy3zWl91kT+s3PnTpo1a/bW+/v4+Oi+WD0viXTq1Ck8PT0B+PTTT1m+fDnjx4/n119/pUKFCq84Ws5iamhMd9d/p739I/o4tUfXBkCdombf2H0AjKlThyqOjgBcDg1l7tGjygcrRCYplnCOGzeOH374gcuXL9OrVy+mT5+u1KmFyBFOnz6dZrlPnz5Zmui9OJAivUEUL5o1axa2tra6R4kSJbIsDiEyo169epibm6dZ9+233+opmpynbUkv7EysADgQco6Sg8ti5ahdvvbHNe4evouxoSEr2rfHyMCAD9zd6V+tmj5DFuKVFGt7d3V1pVOnTgCUL1+eTz75RPdcSkqKlB4QeVbjxo1RqVQEBARw6dIl3frndWizyvOBFFZWVkRHR+Pg4JDhtr6+vowcOVK3HB0dLUmnUFRUVBQVK1akdu3aupb7EydOZLofZ15nbmTKB6Ub8tO1najR8GvIIbynN2Z7v+2Athh83+N98XB05NKgQZQrVEjPEQvxaoplec9Hp6e3PHLkSJk+6hWqL1nCQz0NAHG0suJU//56OXdeMWXKFADmz5+fpvC0mZnZO9cGDAkJoVChQpiYmODt7c3Jkydp3749x48fp3Xr1hnul9P6rIn859q1a0yePDnNOn0P1slpOpSqy7pbB4hJjmfP/dP0+qAZhecX5vGlx4T4h3Dp10tU6lZJkk2RKyiWcG7evDlNf7W7d+/qloOCgiThfIWHsbHcf6EEiMhdGjZsCEDlypXfaWq9nTt3sn37dgICAliwYAFDhw5l8ODB9OnTBx8fH2bOnImvry8XLlwgODiYefPmZdVLECLLLV68mHr16qVZV6tWLT1FkzNZGpvxvksDlt/YTapGzfrAv/jf3Oas9daWd9rvu58KHSpgZJb2o/zx06fEJCbiWrCgPsIWIl2KJZzu7u706tUr3ed++eUXpcLI1QxUKopaWSlyrgexsag1mtdvKDJt6dKlnDx5ko0bNwLw0UcfMWrUKDw8PDK1f5s2bV6ad/2PP/7Q/Vy4cGGWLVuWdQELkY3+m2wCrF+/Xior/Edn5/psuP0XcSmJ7Lp3ko8aN8e1hSu39twi6m4UJxacoO7ndQFtLdMNly7x2Z9/UrpAAY726YORgeLVD4VIl2IJ57Rp09L9AwPg5uamVBi5WlErK+690O8uOznNmyetqlns2LFjrFmzRrf8ww8/MHToUFauXKm/oITQkyNHjtCvXz8CAgJQq9W6wu+ScKZlbWJBR+d6/HJzP8nqVNbfOkjXuc257XkbjVrD4RmHqfJJFSwKWZCsVjP1778Ji48nLD6e744fZ3SdOvp+CUIACo5SzyjZBKhbt65SYQihN2XLlk0zraWNjc0rB/YIkZctWrSIQ4cOMWTIEFJTU7lz5w5jxozRd1g5UheXhpgZmgCwLegYRmXM8fzYE4DE6ET+mvoXACaGhixv357n8zd9cfAgN8LClA9YiHTkiLb2/3YcFyIvunPnDufOndMtnz17VqZ1FflWyZIlKVSoEGq1WrccFxen56hypgKmVrQvpa3DmaRO4dfbf9N4emOMLYwBOL34NE+uPwGgTokSDPfyAiAhJYVPtm6V7lEiR1A84Vy+fDlOTk4YGRlhaGiIgYEBX375pdJhCKG4CRMm0LlzZywtLbG0tKRLly5MmjRJ32EJoRdXr17l7t27pKSkMGfOHJYvX86RI0f0HVaO1bV0Y0wMtL3gttw9Qqq9ijqfa2+Xv1gMHuDLJk1wfTZA8UhwMGP37uXMgwe6R1BUlPIvQOR7ihe/nDt3Lvv376dMmTIYPOvM/LxsjBB5WaVKlbh27RrXr18HoFy5clJ/VuRbw4YN49GjR4wfP54+ffoQFhbGV199pe+wcqxCZjb4lKjF73ePEJ+axKbAw3w0uimnfzpN7INYrm+9zp2/7+Dc0BkLY2NmNmnCB5s3A9q51uceO6Y7lpmREdeHDKGkra2+Xo7IhxRv4XR3d6dcuXK6ZBN457nUL126xOTJk5k5cybNmzcnJCTkXcMUIstpNBpWrlzJli1bcHNzY/369foOSQi9adSoETVr1qR48eL4+fnh7+//TlNd5gfd3ZpgqNJ+dm4KPEyiSSpNvmyie37v6L1o1Nrb52729hkeJyElhSfSfUEoTLHmldWrVwNQqlQpPvroI+rXr68rPP3LL7+wZ8+etzpuSkoKo0ePZteuXRgYGNC1a1fs7OyyKmwhssyIESMICwsjJiYGExMTIiIiGDduHLNnz9Z3aLnKkupLiH2on4kQrByt6H9KJkLICsHBwQwaNIiDBw8C0KRJE3788UeZ8eoVipgXwNupBnvvn6aVUw3UGjUevTw4Mf8Ejy48IuRUCBfXX6Tyh+82oYQQ2UGxhHPmzJnUrq3t9GxoaMjRo0d1z92/f/+tj3vy5EkMDAxYsGABMTExlCtXji5dury0XWJiIomJibrlrJzDWojMMDAwYM2aNQwaNAiVSsXQoUMZPXq0vsPKdWIfxhJzX0p25XZ9+vShbdu2ui9cBw4c4JNPPmHv3r16jixn61uuFf3KtcLezEa3rvnc5vzSQlvP+sD4A1ToWEFf4QmRIUXrcKaXCAJs3779rY8bHBzM8ePH+fXXX7GysqJJkyY4OjrSoEGDNNvNmjVL6rsJvVKpVGn+BXj06JG+wsn1VAYqrIoqMxFC7INY3a1KkTWKFi3KZ599plt+7733OHHihB4jyh0KvZBoPufa3BU3bzdu+t0kKiiKE/NPYNHLVQ/RCZExxRLOjJJNgLZt2771cW1sbChfvjzW1tYAeHl5cejQoZcSTl9fX0a+UDQ9Ojpabt0IRVlaWtKvXz+uXbvGrFmz2Lt37yvr04pXsypqxch7ykyEMM9pnrSqZjEbGxtiYmJ0f7tjYmIoWrQooJ32cuDAgfoML9dpPqc5t/bc0haDn3mYRj7F9B2SEGnk+iGyNWvW5MmTJ6jVagwMDAgKCqJdu3YvbWdqaqrrMyqEPkydOpUVK1YQGRnJmTNn6NmzJ71799Z3WELoxZEjRyhRogTu7u4AXLlyhYoVK9K4cWMCAgIk4cyEuJQE/rhzhAKm1rR+ryZV+lThzM9nSIpJImjBBcxKGZGQkvLSfmZGRhSysNBDxCI/y/UJp729PdOnT2fYsGEUKFCAwoULv7I1VQh9mT9/PsOHD+eTTz7RdyhC6J2zszPffvvtS+s1Gk2660Va0UlP6XZwFtHJcTiY2dKsWFUaT2vMxXUXSX6azPXlFzhxrCcpTmZp9guPj2fZmTOcffBAyiIJRSmecF64cIHAwEBA+wfHw8PjnY/5wQcf8MEHH7zzcYTITkuWLOHMmTO0atWKTp06YWJiou+QhNCb+fPnv9StKTQ0FAcHB1xdpf/h69iYWFK5YGn+eXSJJwnRnA+/RQ3HctQdW5e/Jv2FJlXDlS9P0HVrV90+tyMiaLJqFVGJiZy4f5+Wbm6YSS1goRDFftMuX77Mhx9+yP379ylSpAgAjx8/plixYvzyyy+89957SoUihF78/PPP1K5dm127djFgwADs7e35+OOPdbcUhchPSpQowa1bt3jw4IFuesv58+ezefNm6V+fSR+VaYaVsTk93ZpS0qowALVH1ub04tPEhMRwfdt17vx1B+dGzgC42NlRtWhRDt65Q2BkJPOOHWN8/fp6fAUiP1Es4fT19eWnn36iVq1aadYfP34cX1/fdxqpLkRu4O7ujoGBAS1btiQ2Npavv/6aNWvWyEh1kS/16dOHffv24eLioqvccPPmzUzvv3PnTvz8/LC0tMTZ2fmlPp/Vq1fHykpbxSA5ORljY2P++uuvLIs/J6hgV5IJniXTrDOxNKHJjCZs/XgrAHtG7aGffz9UBipUKhXzvb3x/Okn1BoNMw8fppeHB8VtXh75LkRWUyzhLF68+EvJJmhHlTs5OSkVhhB607t3b0qXLs0vv/xClSpVGDduHB06dNB3WELoxYULF7hz506aMmFr167N1L6xsbGMGDGCK1euYGRkRO3atWnevHmaW/Fjx47l/fffB2DdunUkJydn7QvIwSr3rMzx747z6PwjHpx5wIW1F/Doqe2+VqlIEQZVr85Cf3+eJiczdt8+funYUc8Ri/xAsaktHz58yKZNm4h7YTqtuLg4Nm7cyMOHD5UKQwi9OX78OFZWVpw8eZLdu3fTpUsXjI2N9R2WEHpRs2ZNYmLSlpp6Mfl8lePHj+Pi4oLRs/6HNWrUwM/PL802z5NNgF9//ZWuXbuSkcTERKKjo9M8cqMUdSohcWEYGBrQYm4L3fpdg3exsctG9vnuIywgjGmNG1PQ3ByAtRcvcjQ4WF8hi3xEsYRzwYIFrFy5Emtra2xsbHSPVatWMX/+fKXCEEJvfv75Z6ZNm4azs7NuXXh4uP4CEkKPunTpQvny5albty5NmjShcePGjB07NlP7hoaG6up3gramZ2hoaLrbnj59mvfee++VZfFmzZqFra2t7pHb+pCqNWq23D1Kt4Mz8fVfhlqjpnSz0hSupO3XmRSTxJVNVzg65ygLyy8k6NfrTG/cWLf/0D//RK2RiQ1E9lLslnqJEiXYsWMH4eHh3L17F9DOq16wYEGlQhBCr9q2bZvhIAkh8ptPP/2UL7/8ktKlS6NSqdBoNCxYsCBT+zo4OKRpHY2OjqZcuXLpbrto0SKmTJnyyuPl9olBVKjYfe8UD+MjAPjn4SXcY4sTevmFJFwDmlRtUrmtzzYGXv2UxYULc/HxY04/eMCKs2fpU7WqPsIX+YTi9RDu3btHUFAQoJ1TXRJOkV/069ePP//8k9KlS2NoaAi82SAJIfKSMmXKvFSTNrNJnpeXF4GBgaSkpGBkZIS/vz/Dhg0jKCgIJycnDAy0N+9CQ0NJTEx87TiB3D4xiEql4iO3ZnzuvxSAVTf30XVXJcioh4IKLqw4x4IBrWi8ahUA4w8coHPFitiamWWwkxDvRsoiCaGQM2fOEBQUpPswhMwPkoDXj8rds2cPq1atomLFipw5c4alS5dSoECBLItfiKxUpUoVpk6dSp06dXTJXmZb/K2srJg3bx5Dhw7F0tKSXr164erqSvXq1Vm6dCmenp6AthtLv379svNl5BhehStQ1taJG1H3uBF1j/NJ1pDBXXKNWkPUnSg6OTvTuWJFDt+9y6ymTbHOxUm3yPmkLJIQCvHw8CA1NTVNwmlvb5+pfTMzKvfzzz9n5cqVeHp6MnjwYFavXs2wYcOy/HUIkRXmz5+Ph4dHmlJFb9Li7+Pjg4+PT5p1p06dSrM8fvz4d4oxN1GpVPRya8aE0ysBOF3tAeVVGWWcEBYQRmpSKj+0aoW5sTE2kmyKbCZlkYRQSHR0NO7u7tSoUQNTU1M0Gg0nT57E29v7tftmNCp38ODBum2KFCnCkydPAIiKiqJy5crZ80KEyAKDBw9m+vTpadatXLlSP8HkEfUc36O0tSO3Yx5yzyaSwpUsKXgu/Y/5B6cfsKLBCt7/7X1sSlopHKnIjxRLOJ+XRWrdujUWFhaAtizSzp07pSySyBeuXbvGhAkT0qy7d+9epvbNzKjcr776iqFDh7J161aePn1KpUqVMjxeYmIiiYmJuuXcWgZG5F7Tp08nIiKCY8eOAVCnTh169+6t36ByOQOVAT3dmjP17BoAYr6wwv79RG1fTg2g0t5OVxmo0KRquH/iPj9V+YmOazvi5u2mO05MYqLcXhdZTrGEc8GCBQwaNIgPPvgAS0tLQJtwent78+OPPyoVhhB6s3jxYurVq5dmXXqt/ul53ajcpKQkfHx8OHXqFI6Ojvzwww8MGzYswz6is2bNYurUqW/xKoTIGn///TddunTR9TOOjIxk48aN1JepFt9J42IeLL/hR/DTUAJMHvHJ2Y9IWP+EqDtR2DrbUrVPVRKiEtj4/kYiAyOJD49nbeu1NJjYANcRVfA9eAD/+/e5OGgQpjLPushCUhZJCIXUq1ePlStXsmvXLgDatGlDr169MrXv60blJiYmEhkZqesT6ujoSHx8fIbHy+1lYETut2jRIs6ePUuxYsUAuH//PiNGjJCE8x0Zqgzo6daMmefXA/BH/Am+mTXgpe36n+7P1t5bub7tOmjg0PRDbP/dn62t4nlqBfNPnODzunWVDl/kYYoVfn+uYMGCeHh4oFKpuH79Ok+fPlU6BCH0YtKkSWzcuJGqVatStWpVfvvtNyZPnpypfV8clTtmzBjdqNyOHTty4cIFrK2t+frrrxkwYAAzZ85k48aNzJgxI8PjmZqappmAwUbmUhYKc3Z21iWboO3nX7JkyVfsITKrefGqFDXXNuacDL3O1cigl7YxL2DOB1s+oNlXzVAZausn2V6OZ8BPUCIIph86xIP/zAQlxLtQrIXz008/5ccffyQ0NJSmTZty9+5dTExMMDQ0ZMuWLXh5eSkVihB68fjxY3bu3KlbHjduHH379s30/q8blfvpp5++e5BCKCQwMJBz587pShidPXtWV6NZvBsjA0N6uDVlzsWNAKwO2MusGn1e2k6lUlH387o4eTmx6YNNxD6MxSYGPl4Be5sn4Vt+Hys7dFA6fJFHKdbCuWXLFkA7sGHq1KlERUURGhrK7t27mTlzplJhCKE3zwfLvW6dEPnBhAkT6Ny5M5aWllhaWtKlSxcmTZqk77DyDG+nGhQ2swPgn0eXuRl9P8NtSzUoxYCzA3Bu5AyAgQZa7oGE8Rc4cjVQgWhFfqD4LXWVSkWHF74xeXh44Obm9oo9hMgbkpKSGDZsGL/99hu//fYbw4YNQyPzF4t8qnLlyly7do2TJ09y8uRJrl69KhOAZCETQyO6uf47X/rgIz9wKvRGhttbOVrRc29P6vn+O7CxwjXY2nAtIWcfZGusIn9QPOE0MTHh8ePHadb9d1mIvGju3LnY2toyZ84c5syZg52dHXPmzNF3WELoxe7du/n6669xd3fH3d2d77//XspzZbG2JWthZ/ysKkxqIguubHnll1wDIwOazmzK+1s+INFC26/TMjSVpbWXcnb5WUViFnmXYn04W7ZsySeffIJGo+Ho0aP873//IyAggB49esi3WpEvmJmZMW3aNKZNm6bvUEQWWlJ9CbEPY/VybitHK/qf6q+Xc7+rb7/9li+++EK3XL16dUaMGMGyZcv0GFXeYmpoQl1Hd3YGnwQgMOYhxx5fpU6Riq/cr2L78tTe1Z7t3bdQPAQ0iWq29dlG0D9BtP6hNcYWxkqEL/IYxRLOFStWvLSuTJkynDhxQqkQhNCrkSNHcuPGDXbs2AFAly5dGDBgAE2bNtVzZOJdxD6MJea+jOZ9Ux4eHtR9oexO/fr12bp1qx4jyns0Gg0BUWn7bv58bRe1C1dApVK9ct+2DT1YPvsyIQsCqPFsbOK5Fed4cPoB7296H/symZuWV4jnpKqrEAp5+PAh27Zt0y2vW7eO/v37S8KZR6gMVFgVVWaKwNgHsWjUubv/771790hOTsbYWNtalpSUxP37GQ9sEW/uZOh1bvxnsNDNmBBOhl6nVuHyr91/bhtvvCPDaNfZlSfTzpEcl8yjC49YUm0J7Ve0p2KnV7eUCvEiSTiFUEjJkiUxMPi327SRkZFMfJCHWBW1YuS9ka/fMAvMc5qX61tVO3TogLOzMx4eHgBcuHCBBQsW6DmqvEOj0bD0+p+oUKHh3y8nKlQsvf4nNR3KvbaV07VgQa4PGYKBSkVo2xr81uk3nlx7QlJMEhs7b8RrhBfNvmqGobFhdr8ckQcoPmhIiPwqODiYP/74g8ePH/P48WP++OMPQkJC9B2WEHrRuXNnDh48SJs2bWjTpg0HDhygY8eO+g4rz0hWp/IoPiJNsgmgQcPjhEhikxNITE167XEMniWlDhUd6Offj/e6/jvm4vi3x1nVaBXR92Swl3g9xVs4Q0NDcXBw0C37+/tToEABKY0k8rxZs2bRo0cPOnXqhEqlon79+qxevVrfYQmhN2XLlqVs2bL6DiNPMjE04uf6I4hMenk2v6TUZIafWEQZm2KM8+ia+WNamVBwZlVa1nVi78g9qJPVBB8N5qcqP9FxXUdcm7tm5UsQeYziLZzTp09Ps2xmZpZmTmch8prnA+NKlizJoUOHiI6OJioqir/++kum8hNCZJsi5gUoZ+uU5uFi5ciUM2u4EXWPncEn2RmUuYG7dyIj+d+GDTRZvZpj1dR8cuQTbEvaAhD3JI5fWv7C39P+zvV9i0X2USzhPHToEIcOHeL+/fu6nw8dOsSTJ0+UCkEIvZg/fz4VKlSgb9++bNu2DUNDQ6yslBlcIoQQLzIxNKJ/+dYAOFk6UM6uRKb2exIXx7br1wGY8vffGFe0o/+Z/pRpXUa7gQb+mvwXa1uvJe5JXLbELnI3xW6pT548GYCAgADdzwDm5uZ06dJFqTCEUNy6detITU3l0KFDbN++nQkTJuDs7Ezbtm1p27YtRYsW1XeIQuQI9+7dw8nJSd9h5HktnaqTrE6hUVEPrIzNM7VP9WLF+NjTk+XnzhGdmMiE/fv5uV07um3vxj9f/cPBiQfRqDXc2n2Ln6r8xPsb38fJS/4vxb8USzgPHjwIwNq1a/nwww+VOq0QOYKhoSGNGzemcWPtVHNXr15l27ZtdOnSheTkZKZOnUrLli31HKUQ2e/QoUMZPjd//nw2b96cqePs3LkTPz8/LC0tcXZ2ZuDAgWmej4iI4LvvvsPW1pajR4/Su3dvfHx83in2vMSnpNcb7zOzaVM2Xb1KdGIiy86eZWD16lQrVoz6vvVxquXE5m6befr4KdH3ollRfwUtvmlBzc9qvnY0vMgfFB80lF6yGRAQQJkyZZQORQhF+fn54e3tDUCFChWoUKECY8eO5cmTJ0REROg5OiGU0a1bN8qVK0dCQgJXrlyhYkVtLcfLly9nevBobGwsI0aM4MqVKxgZGVG7dm2aN2+Oq+u/g1ZGjhzJlClTKFWqFH369JFpM18jWZ3ChfBAqhXK+LO4iJUVkxo0YPTevWiAYX5+HP74Y1QqFS5NXBhwdgCbum4i6HAQ6hQ1fsP8CPoniHZL22FqY6rcixE5kl7KIvn7+7N27VpWr17N6tWrGTx4sD7CEEJRo0ePZuzYsRw+fDjNfMaFChWSL1wi35g0aRIHDhygbt263L17l6NHj3L06FGCgoKoU6dOpo5x/PhxXFxcMDLStpnUqFEDPz8/3fMajYaDBw+yd+9evvnmG5YsWYKjo2OGx0tMTCQ6OjrNIz95HB/J0GM/MurET5wLu/XKbT+rVYty9tpZho4EB7Ph0iXdc9bFrOl1oBd1xvz7/3hl4xV+rvEzjy4+yp7gRa6heMI5ZcoUpk6dyqxZszh48CCrVq0iLCxM6TCEUNykSZPw9fXlzp07DBw4kKFDh7Jr1y59hyWEogYMGABASEgItra2uvW2traZTvRCQ0OxtrbWLdvY2BAaGqpbfvz4MXfv3qVChQqMGjWK2NhYZs2aleHxZs2aha2tre5RokTmBtLkFX73/LkUcYdUjZrJZ1YTlpDx/4OJoSHfvtD9Z8zevTxN+reep4GRAc2/bs4Hf3yAqa22VTPsRhhLay3l/Orz2fciRI6neMIZFhbGjh07aN68OStWrGD//v00adJE6TCEUFyXLl2wtbWlZMmSmJub88cffzB69Gh9hyWEXjx+/Jg5c+Zw8uRJTp48yddff83Dhw8zta+DgwMxMf/OtBQdHZ2mvrONjQ2gbfkEqFOnziv7jvr6+hIVFaV7BAcHv81LyrU+dGuqu5UenhjD1LNrSFGnZrh9qzJlaPPsrsz9mBhm//PPS9uU/195+p/uj2MVbctySnwKW3ptYXv/7aQkpGTDqxA5neIJp5mZGUCab7J3795VOgwhFPfxxx/j6OjI2LFjcXR0ZO/evVy5ckXfYQmhFytWrOD48eN4e3vTqlUrTp06xYoVKzK1r5eXF4GBgaSkaBMXf39/vL29CQoKQq1WY25uTs2aNQkMDAQgKCjold1WTE1NsbGxSfPITwxVBkyu0gMHM22L89mwWyy9/ucr9/m2ZUuMn03Ve/Hx4zTdhJ4r6FqQPkf7ULVfVd26Mz+fYVmdZYTfCs/CVyByA8UHDV27do3NmzdTqVIlPDw8sLW1xcLCQukwhFBc3bp1UavVODo6Urt2bcqVK6fvkITQGycnp0yPSP8vKysr5s2bx9ChQ7G0tKRXr164urpSvXp1li5diqenJ0uXLuWrr77Czc2N69evM2fOnCx+BXlLAVNrplb9iM+OLSRVo2btrQO8V8CZeo7vpbt9GXt7vmrWDLeCBfEpWzbDkehGZka0XdKWkvVKsmPgDlLiU3h49iFLqi3hf6v+R/n25bPzZYkcRPGEc8uWLYC2TIyjoyNhYWH07NlT6TCEUFzfvn3p27cvMTEx7Nixg7p161K+fHmWL1+u79CEUNyjR48YOXIkCQkJrFmzhs8++4yvv/4a+2cDUl7Hx8fnpTJHp06d0v1cqVIlubbeUKWCLnxaoS3fX9kKwIxz61hWfxTFLNP/PxlRu3amj+3xkQeOVRzZ2HkjYTfCSIxK5Nf//UqdMXVoMqMJhsaGWfIaRM6l+C11Q0NDDA21v1hdu3Zl8ODB73z7IjQ0lOLFi7N48eKsCFGIbDF69Gj27dvH2LFjGT16NHFxcTg7O+s7LCH0YvTo0TRp0gQLCwssLCwYOnQoY8eO1XdY+d77Lg1oVNQDgNiUBCaeXklianKWHLtIpSL08+9Hxfcr6tYdnXOU1U1XExMS84o9RV6geAtnVtNoNEycOJHq1avrOxQhXum7777j1KlTtG/fniNHjrxxsimFrkVeUqJECfr06aNrlfTw8KBAgQJ6jkqoVCrGVf6AW9EhBD8NJSD6Pt9d+p2xHh+8cj+NRsP2GzeISUzkw8qVM9zO1MaUzr925mS9k+wZvQd1spqgw0H8VOUnOm3ohEtjl6x+SSKHyPUJ57fffkvPnj1ZunSpvkMR4pUWLVpEv3793mpfKXQtMmtJ9SXEPozVy7mtHK3of6p/prZ98uQJgK7vX0xMDDdv3sy22ETmWRqbMb1aLwb8M59EdTI7gk9QqaALrUvUTHf75NRU2q5fz+5bt7AzM6OlmxuFXjE2Q6VSUWtoLYrXLM7GLhuJDo7m6eOnrGm2hsbTG1NvXD1UBjI7UV6TIxLO8PBwChYs+Mb7nThxgsTEROrVq/fahDMxMZHExETdsnwYC6W9bbIJGRe6fj5pwvNC13Xr1iUqKgq1Ws3w4cMzPJ5cD3lX7MNYYu7n/NuTzZs3x93dnYSEBFq2bMnZs2dZtGiRvsMSz7jaFGN05feZcW4dAN9c3ERZWyfcbIq9tK2xoSGFLS0BiExI4IsDB1iUibsrTl5ODDgzgN8//J1be26hUWs4MOEAwUeCaTilIVd/v0rUnShsnW2p8kkV7Mtkrn+vyJkU78M5ceLEl9b175+5b8T/tXXrVjQaDbNnz+bixYvs3r2bdevWpbttfi/sK3I3KXQt3pTKQIV1cWtFHm/TGvX++++zefNmRo4cSbt27fjnn3/o1KlTNrwT4m15O1Wn3bM515PUKXxxaiWxyfHpbju7WTMsjY0BWHLmDOczWVPVopAF3Xd1p9HURvDs1yhgVwBLay7l6JyjXP7tMkfnHGVh+YWcW3nuHV+R0CfFWzg3btyIjY0NY8aMISQkhF69enH06NG3OtbMmTN1P1+7dg0vLy+6d++e7ra+vr6MHDlStxwdHS0fsm+p+pIlPIzVzy07RysrTr3lF5TcLL1C1y+WVUqv0PWrysDI9ZD3WRW1YuS9ka/fMAvMc5r3xq2qP/30EwMGDKB8eW1ZnJ9//pnZs2fLyPIcZqh7B65F3eNG1D3uxT1h9vkNTK/W+6UySMWsrZnYoAG++/ej1mgY6ufHX716ZVgu6UUGhgY0nNQQp9pObPpgEwkRCQBoUtPW9tzWZxsl65WkoNub3xEV+qd4C+dvv/1GgwYNaNasGTVr1qRdu3asX7/+nY65cuVKLly4wJ9//sn+/fvT3Sa/F/bNSg9jY7kfE6OXh74S3ewSEBCQqe2k0LXIa4YPH07Tpk11swv169cPy2e3ZUXOYWpozPRqvbAyNgfg74cX+fX23+luO8LLC9dnA78O3b3Lpjec2MK1uSuVulfKeAMVnFl25o2OKXIOxVs4d+zYwdmzZ4mMjKR9+/Y4OTm988jE3r1707t376wJUGSagUpFUSsrRc71IDYWdTozWeQ2/v7+3Lhxg9RU7bRxv/zyC3v27HntflLoWuQ1n3zyCU5OTlStWpWff/6ZNm3a6DskkYFiFvZM9OzOOP9lACy/4UdLp+oUME3799/UyIh5LVvSfsMGAEbv3UubsmWxeHarPTPiw+JRGajQqF/+e69J1fDowqN3eCVCnxRPOKdMmcK4cePYsGEDRkZG/Prrr/Tt25cbN24oHYp4R0WtrLg3Uplbdk7z5nE/JucPhHiVKVOmcOrUKe7cuUONGjUICgoiMjIy0/tLoWuRlxgaGuLr60vDhg358MMP2bNnD0lJSfoOS2SgbhF3erg1Zd/9M0yv1vulZPO5tmXL0sLVlT23bhEUFcWcI0eY3KhRps9j62yr68uZnpt/3mTn4J00mtIISwdpEc9NFL+l7uvry/Tp03WjbT/44AOGDBmidBhCKC4sLIwdO3bQvHlzVqxYwf79+2nSpIm+wxJCL65evcqJEyeoU6cOZ8+e5d69eyxbtkzfYYlX6FPWm+X1R1HeLuP+3iqViu9atsTo2TzrXx05QlBUVKbPUeWTKvCqm1kaOPXjKb53+54jXx8hJSEl08cW+qV4wjlt2rSX1sXFxSkdhhCKMzMzA9KWILp7966+whFCryZOnKgrh2dnZ8fmzZvZ8OxWrMiZjAwMsTbJuL7mcxUcHBjybABjqzJlXtVg+RL7Mva0W9YOlYEKlaEqzb/lO5TH2FJ7ez4xOpF9Y/fxQ/kfuLThEpo80OUqr1P8lnrp0qVfWhceHs64ceOUDkUIRV27do3NmzdTqVIlPDw8sLW1xeIVxZGFyMsaNmz40jop/J67pKhTWXr9TyoVdKFuEfc0z01u1AifsmVpms5n/ut49vakZL2SnFl2RleHs2qfqhR0K0jsw1gOTjrI2WVn0ag1RN2NYnO3zZyYf4IW81pQorZU28ipFE84GzRowNSpUwFITk7m1KlTBAUFKR2GEIrbsmULoO275ujoSFhYGD179tRvUEIorHv37nzzzTfUqVMnTckcjUZDRESEND7kEnEpiYzzX8rZsFtYBZmzrP5Iiln8W5jdzszsrZLN5wq6FaTZrGYvrbdytKLtkrbU/Kwme0bt4fbe2wDcO36P5XWW497Fnaazm1LARaZJzWkUTzhXrlyZZtnNzS1NPUAh8ipDQ0OuX79OYGAgnTt35t69e1KOSOQ7vXr1olChQjRs2FDX+ADahHPKlCn6C0y8EXNDE2yMtXdo4lMSuRJxN03CmR6NRpOpupyZUaRSEXrs7sFNv5vsHb2X0CvaiTAu/3aZa1uuUWtYLeqPr4+ZnVmWnE+8O8UTzkOHDul+VqvVPHjwAH9/f6XDEEJxy5cvZ8aMGTg7O9O0aVPGjBmDj48PvXr10ndoQiimZcuWAPz4448vdSmZPn26PkISb0GlUjHOoyvRyXH0LdeaygVdMtxWo9Gw4dIlvj56lAMffUQBc/Msi6FMqzK4NnflzNIzHJx0kLjQOFKTUjk65yhnl5+l0dRGVOtfDUNjwyw5p3h7iiec3bt31xWkNjAwwNHRkW+++UbpMIRQ3JEjRwgICGDw4MEYGxuzceNGBg8eLAmnyFdebHT4r/nz57N582YFoxHvwsrYnAW1B792u+mHDjH5r78AmPLXX8xv1SpL4zAwMqD6wOpU6l6Jw7MOc/zb46QmphIfFs+fQ/7k5PcnaTG3BWXalMmyFlbx5hRPOL/88suXirTfu3dP6TCEUJyjoyMGBmkLQ8gfP5HfdOvWjXLlyqU7qlgGDeUNianJmBr+W+z9kypV+OrIEeKSk1no70//atVwL1w4y89ramNKs1nNqD6wOvt993Np/SUAwq6Hsb7telyauNDimxY4ejpm+bnF6ymWcD7/Vlu6dOmXvuHKt1qRH4SGhrJ27VrCw8M5duwYe/bseaPC70LkBRMnTmTQoEHpPvfTTz8pHI3ISmqNmlUBe9kfcpaf6g7H0ljbf9LJxgbfevX44uBBUjUahu/ezZ4ePbLtC7ddKTs6retErWG12DNqD8FHggEIPBDIT1V/wrO3J02+bIJ1MetsOb9In2IJZ7du3Shbtmy6z8m3WpEffPXVVwwbNowDBw5w4MAB2rRpw/fff6/vsIRQVEbJJvBGc6nv3LkTPz8/LC0tcXZ2ZuDAgWmeHzhwINeuXdMt//7777q6nyJ7LLyynd8CtfOszzq/genVeumSylG1a7Ps7FnuREay7/Zttl6/zv/Kl8/WeJxqOfHx4Y+5uvkq+8buI+J2BGjg3IpzXP71MnU+r0Od0XUwsTTJ1jiElmIJp3yrFfndmjVr6N27N6tXr9Z3KELo3cOHD5k2bRoBAQGkpqYCEBAQQI8ePV67b2xsLCNGjODKlSsYGRlRu3Ztmjdvjqurq24bR0dHFi9enG3xi5d1cq7HruATxKYk8PfDC/wWeIgPSmvrrZobG/NNixZ0+u03AEbu3o23mxtmRtmbhqhUKip2rkjZtmU5+cNJDk0/RGJUIslxyfw95W/OLDlD4y8b4/GRBwaGis+Fk68o9u66u7tz+vTpdJ8bMGCAUmEIoTdz5syhRAkpSiwEwOjRo2nSpAl2dnZMnjyZ3r1706BBg0zte/z4cVxcXHRTJNeoUQM/P78028TExDBz5kxmzJjxUjk+kT2KWdozwbO7bnnR1e1cCA/ULXcoX54mLtrR7IGRkcw7dkyx2IxMjagzqg5Dbw6l5mc1MTDSpj8xITFs+2QbP1f/mcADga85ingXiiWcU6dOJSQkhKCgIIKCgggNDVXq1ELkCPXr10/TAgOwatUqPUUjhH6VKFGCzp07U6xYMRo2bMhHH31E8eLFM7VvaGgo1tb/9r+zsbF56TOlR48efP7550yYMIHdu3ezdu3aDI+XmJhIdHR0mod4O/Uc3+ND1yYApGrUTD69iojEGEDb2jjf2xvDZ7fZZx4+zH2F32uLQha0WtCKQZcGUa5dOd36h+cesrrpata3W8+T608UjSm/UCzhLFu2LG3btmXFihX4+Piwe/dupU4tRI5gbW1N/fr1mTBhAtOmTWPatGksWrRI32EJoRcPHjwAIDo6mlOnTnH79m0OHz6cqX0dHByIiYnRLUdHR+Pg4JBmmypVquhaQBs2bMjBgwczPN6sWbOwtbXVPeROxLvpW64VVey1X66fJEYz9ewvpGrUALxXuDCDqlcH4GlyMl+84v8lOxUqV4iuW7vy0YGPcKzy76j1G9tvsOi9Rez6bBdxT+L0EltepXiHhcmTJ+Pu7p6mn05iYqLSYQihuH379tGiRQtMTEzQaDS6hxD5UZUqVdi4cSMDBgygadOmlC1bls6dO2dqXy8vLwIDA0lJSQHA398fb29vgoKCUKu1ic3nn3+u2/7WrVu4ublleDxfX1+ioqJ0j+Dg4Hd4ZcLIwJDJVXpS0FTbCn36SQDLr//b5WFq48YUsrCgR+XKTG/cWF9hAuDS2IX+p/rTfmV73ah1dYoa/x/8WeC2gKNzj5KSmKLXGPMKxQYNvVj+4L+lEMaMGcOCBQuUCkUIvfjqq69e+kBt1uzluYKFyA+GDRum+/nJkyckJCRkepS6lZUV8+bNY+jQoVhaWtKrVy9cXV2pXr06S5cuxdPTk8ePH+Pr64uJiQlhYWFpptH8L1NTU0xNTd/5NYl/2ZvZMLXqRww/vohUjZrVN/fhXsCZOkUqUtDcnGuDB2P/n5mm9EVloMKzlycVO1fk2DfHOPLVEZLjkkmMSmTvmL34/+hPs6+aUbFzRamd/A4USzg3b97MqVOnAO23zZo1a+qeCwoKkoRT5Hnptd6cOnWKunXr6iEaIfQvMTGR0NBQXavk0KFDWbFiRab29fHxwcfHJ826558xgAwUygE87V3pX741i67uAODLc2tZVn8URS0K5phk80UmliY0nNSQqn2rcuCLA5xbcQ40EBkYyaYumyhRpwQtvmmBk5eTvkPNlRRLON3d3TOcwu+XX35RKgwh9ObatWuMHDlSVwZGo9EQERGRpqVHiPxiypQpzJs3D3t7e926iIiITCecInfoVroxl8LvcPjRJWKS4/ni9EoW1vkszUxEAFEJCRioVFjngJZm62LWtF/Wnlqf1WLP6D0E7teOXg8+Gsyy2st4r+t7NJ3VFDtnO/0GmssolnBOmzaNevXqpfvcq/rWCJFXTJ8+XTdQaNKkSdy9e5cNGzboOywh9GLLli2EhIRgZWWlWyd3uvIelUqFr2c3bh+ex/24MK5H3eP7K1sZXUl7x0et0bDi7FnGHzhAj0qV+KZlSz1H/C9HT0d67u1JwK4A9o7ey5Nr2tHrlzZc4uofV/Ea7kU933qY2ZrpOdLcQbFBQxklm4DcUhT5QqlSpahevTrW1taUKlWKBg0aYG5uru+whNALT09PzMzSflBnNBudyN2sjc35snpvTAy0bVxb7x5l9z1t94eQmBiG/Pknj58+ZcHJk1x7krNKEqlUKsq2KcvACwNpvbA1FoW0XQFSE1M58tURvnf7Hv8f/VGnaLuFhAWEsc93H5u7bWaf7z7CAsL0GX6OolgLpxD53e3bt4mJieHp06ds2rSJggUL8vfff+s7LCH0YvDgwdSoUYOKFStiamqKRqPh5MmTeHt76zs0kQ3cbIozslJnZp/X3tWZc2EjZWyKU9qmKJ/XqcO0Q4dIUasZsXs3u7p3z3GDcwyNDanxaQ0qfViJwzMPc+K7E6QmpRL3JI5dg3dx8oeTuLZ05eSCk6ACNIAKjn59lHbL2uHZ21PPr0D/JOEUQiEdOnTgyJEjjBo1iv/973+Eh4fz3XffZXr/180dDaDRaGjVqhV2dnZyu17kaP369aNdu3aULl1al1zcu3dPz1GJ7NSmRE0uht9mZ/BJEtXJTDy9kqX1RzK2Xj1WnDtHcHQ0fjdvsjMgAJ8c2tptZmtG86+aU31gdfb77ufyr5cBeHL1CU+upt86u63PNkrWK4lR4fydcun11avVamJjY7GxsdFnGEIo4oMPPtD9fO3atTfaNzNzRwPMmzcPZ2dnIiMjsyJkIbJNsWLFmDZtWpp10r0q7xvxXkduRN3nVnQI3k41MDM0xkBlwJzmzem6ebN2m927aV66NKbZPM/6uyjgUoDOGzpTa1gt9ozcw73jr/iypIIzy85Q07dmxtvkA4oXfh89ejRfffUViYmJeHp64urqyjfffKN0GELkKpmZO/rYsWNoNBq8vLxeezyZyk/oW9OmTVm1ahUBAQG6KY9nzJih77BENjM1NGF6tV584zWAj8o0w0ClTUO6uLvToFQpAG6GhzP/xAl9hplpJWqX4JOjn+BU5xWlkjQQdSdKuaByKMUTzri4OMaOHcvvv/9O6dKlCQ0N5erVq0qHIUSu8rq5oyMiIli6dCkjR47M1PFkKj+hb1988QVTpkyhRYsWNGzYkIYNG/LHH3/oOyyhgOKWhaheKO0t8+fzrBs8614x/dAhHrwwfWlOplKpKNWgFCrDDPqdqsDW2VbZoHIgxRPO5yUwfvvtN/r37w9AgQIFlA5DiFzldXNH7969m4IFC/L111+zc+dOrl69yuzZszM8nkzlJ/StR48eBAYGpnlMmjRJ32EJPTkfdptSBSzpV7UqALFJSfTfvp0zDx7oHkFRObeVsMonVbQDhdKjgap9qioaT06keAeJBw8e4OPjw5UrV2jZsiUHDhzgypUrSochRK7y4tzRRkZG+Pv7M2zYMIKCgnBycqJr16507doV0M6wYmhoyLhx4zI8nkzlJ/QtNDSUpUuX0rdvX926zLbQi7xDo9Gw/vZBllzbpZ2ZqFp7fjp9GoAdAQHsCAjQbWtmZMT1IUMoaZvzWgvty9jTblk7tvXZlmaUOhpot6wdBd0K5vuuS4onnEuWLMHPz4/q1atjaGhIfHw8kydPVjoMkYdUX7KEh7Gxejm3o5UVp5611L+pbdu2MXnyZM6ePfvabTMzdzTAwYMH2b59OwEBASxfvpxPPvnkrWITIrsFBgbK76cgOjmOX2//TapGzeknAZS1vJThtgkpKTyJi8uRCSeAZ29PStYryZllZ4i6E4Wtsy1V+1SloFtBfYeWIyiecJqbm9OhQwdAO0q9fv36MkpdvJOHsbHczyV9fV5Uo0YNxo4dm+ntXzd3NEDjxo1p3LhxlsQnRHZq1KgRT548oXDhwrp1EydO5Msvv9RjVEJptiaWTKnakxHHF9PDrSme1u7AMX2H9dYKuhWk2axm+g4jR1I84Rw9ejQODg4MHz6cGjVq8ODBA3x9feVWinhnBioVRV+YJi87PYiNRa3JqMNO+kJDQ9P0u7x37x7Vq1fP6tCEyBXOnDlD2bJlcXd31xV+v3nzpiSc+VAVezfWNx5PUYuCnHnwQN/hiGyieML5fJT6+vXrKV26NBcuXEjTh0eIt1XUyop7Cn1xcZo3741bVadPn55mrmgzMzNGjhzJtm3bsjo8IXK8uLg4tm7dqlvWaDQyl3o+VtQic7edYxITszkSkV0UTzhllLrIbw4dOgTA/fv3dT8DpKam6iskIfRu/fr1lClTJs26ihUr6ikakdNYWaRQ1CEJa8tUbgWbExWjTVcG7dzJoY8/ppCFhZ4jFG9KRqkLkc2eD4oLCAhIM0DOzMwszexDQuQnpUqVYsqUKezatQuA1q1bM378eD1HJfStkIUFToVTKFn8KQbPCjc6F0/g/DVLQMXVJ09ouHIle3v2pNgLtYlFziej1IXIZgcPHgRg7dq1fPjhh3qORoicYeTIkWg0Gl3//cOHDzNy5Eh++OEHPUcm9KmkrS0zmjTh54DtunXWlqnMbVOHrw+e53FcHFdCQ6m3fDn7PvqI0nKHNNdQvPD781Hqz2c2adOmjdxSF/lCvXr1+Oeff3TLR48e1WM0QuiXkZERCxcu1NWQXbhwISpVBjO1iHylZ9lG2Bpbpll3OOII/3zyMS52dgAERkZSf8UKrrww45rI2RRPOAH8/f1Zu3Ytq1evZvXq1QwePPitj3Xp0iW6d+/O3LlzGTBgAMuWLcvCSIXIOgMHDuTw4cO65aNHjzJx4kQ9RiSE/iQlJWVqnch/ToZeJyr5aZp1YYkxfH1lNX/26EqFQoUACImJocGKFZwOCdFHmOINKX5LfcqUKZw6dYo7d+5Qo0YNgoKCiIyMfOvjhYaG0q9fPxo3bkxycjJFihShY8eO0moqcpzy5cvj6+urWx49ejTDhg3TY0RC6E+hQoVo3749devWBeDIkSO6CQwyY+fOnfj5+WFpaYmzszMDBw58aRuNRkOrVq2ws7Njw4YNWRW6yEYajYal1/9EhQrNf+aKvBZ1j0nnfmbN+x8yYMteTj94QFh8PE1Wr+bCwIGUetb6KXImxRPOsLAwduzYwYgRI/j2228BGDNmzFsf779Fro2NjTEyevllJSYmkvhCOYX8PsWUUF5iOuU8EhIS9BCJEPo3depUVqxYwZ9//gnA//73P3r37p2pfWNjYxkxYgRXrlzByMiI2rVr07x5c1xdXdNsN2/ePJydnd+pUUMoK1mdyqP4iJeSzedC4sPxPf0TU1t24qsDxhwOCqJPlSo5dvYh8S/FE04zMzMgbcJ39+7dLDn2okWLGD9+PNbpjFybNWsWU6dOzZLzCPE23rVFR4i84O7du5QqVQqVSsUnn3zyVtNbHj9+HBcXF13jQo0aNfDz80vTPevYsWNoNBq8vLzw8/N75fGkQSLnMDE04uf6I4hM+s8t9YQoFl3dyZ3Yh8SnJjH74no+qNmIzhUr8FnNWtL/NxdQvA/ntWvX2Lx5M5UqVcLDw4MGDRpkycW9efNmYmJiMrxF6evrS1RUlO4RHBz8zucU4k1MnTqVdu3a4e/vj7+/P//73/+YMmWKvsMSQlETJ04kKCgow0dmhIaGpmlYsLGxIfSFwSMREREsXbo00zPYzZo1C1tbW93j+aBWoR9FzAtQztYpzaNOEXeW1h9Oi+LVdNv9GvgXdzlPTHJcmv0fP33630OKHEDxFs4tW7YAYGhoSJEiRQgPD+ejjz56p2OuW7eOBw8eMGHCBM6fP4+5uTlly5ZNs42pqSmmpqbvdB4h3oVKpaJPnz706dNHt+7EiRPUqlVLj1EJoaxr166xcuVKNC9MDRsfH88PP/yAi4sLFy9efO0xHBwciHlhpq/o6GjKlSunW969ezcFCxbk66+/5vTp09y4cYPZs2czbty4dI/33+mVo6OjJenMgUwNTZjo2Z0KdiX44co2UjVqToZep98/3zGz+se42hTj+L17NF+zhhlNmjBU/rbmKIolnDNmzGDChAkYGhrq1nXr1g2Ab7/9lhEjRrzVcQ8ePMigQYOoUqUK27dv58mTJ/zwww8vJZxC6JtGo2HTpk3cuHFDN8vQrl27Wk1GbgAAFrhJREFUOH78uJ4jE0I5I0eO1P3tB7h58yadOnWiRYsWrF69OlPH8PLyIjAwkJSUFIyMjPD392fYsGEEBQXh5OSkK7UEsHLlSgwNDTNMNkEaJHITlUpFZ5cGuFoXY9KZ1UQmxRISF8bAIwvoX7Yd/TcdJjYpiWF+fkQlJDCxQQO53Z5DKJZw/vjjj+zfvz/d5wICAt464WzcuDFRUVHvEpoQihg2bBhqtZozZ87QsmVLgoKCMDc313dYQijqxWRzx44d9OrVixEjRrxRiTArKyvmzZvH0KFDsbS0pFevXri6ulK9enWWLl2q6xt98OBBtm/fTkBAAMuXL3+r/qIiZ6pSyI2l9Ucw4dQKrkfdIyE1iQVXN/Fh1VosPHoNgEl//UV0YiJfN28uSWcOoFjCWaVKFa5fv86AAQNe+pDduHGjUmEIoTfGxsZ88803jBgxQje71tixY/UclRDK02g0TJw4kUWLFrF69Wp8fHze+Bg+Pj4v7Xfq1Kk0y40bN36pkonIO4qYF2BhnSHMvbgJv3un8Cpcga9qvI+L5XFG790LwNxjx4hOTOTHNm0wNNBL6XHxjGIJ544dOzh9+jQ//vgj7u7ufPrpp7oR6xUqVFAqDCH05vlt9MjISOLj4zE3N89UfzUh8pLw8HC6detGcHAwx44dS9P38vTp01SrVu0VewuRlqmhCeM9uuFp70YDx0oYqAwYVacONqamDNixAw2w5MwZopOSWP2//2H8Qrc+oSxFBw1Vq1aNZcuWcfr0aYYMGYK7uzuDBg2iSZMmSoYhhF5ERESwYcMGmjZtirOzM+bm5tSpU0ffYQmhqCpVqmBkZMT8+fN59OgRjx49ArStngsWLGDz5s16jlDkNiqVijYlaqZZ169aNWI1kXx17C8ehRux4dIlYhIT2fj++5gbG+sp0vxN8VHqoE08J06cSM+ePfn999/TTPcnRF71/fff6wYnuLm5ERYWhre3t77DEkJRrq6u9OrVi7CwMMLCwtI8J/UvRVZ5khDFXxGHKOPyFGtLM24Gm7AzIIB2Gzawp0cP6dOpB4onnHfv3uXLL79k3bp1vP/++3zxxRdKhyCEXhQuXJiffvqJXr164eXlpe9whNCLcePG0aJFi3SfK168uMLRiLxq973ThCdqS2fVdrHn4aNEYpOS6Vm5siSbeqJYD9q7d+/Sv39/KlasSHJyMufPn2flypW4urpy/fp1pcIQQm+aNGlCr1690qyT332R32SUbAI0a9ZMwUhEXtbdtTEj3+tEcQt75tcZwP6PevGTjw8feXjoO7R8S7EWzrJly1KyZEnmz59PmTJlCAkJISQkRPrtiHyjSZMm/PjjjzRv3lxX82/27NmsWLEiU/vv3LkTPz8/LC0tcXZ2ZuDAgbrn4uPj6dOnD++99x5Pnz4lNjaWb7/9FgMZlSmEyIdUKhUdnOvSpkQtTAyNqFnciprPWtBjk+OxMtZWy3malISliYk+Q803FEs469atq2vduXPnTprnpN+OyA8mTZpEkSJFmDNnjm5dREREphLO2NhYRowYwZUrVzAyMqJ27do0b94cV1dXAJKSkqhWrRqjRo0CoHXr1mzfvp327dtnz4sRQohcwMQwbZoTmRRLv8Pf0sCxMlZJJZj819/s7dmTcoUK6SnC/EOxhPNV/Xbc3NyUCkMIvenRowdLlixJs27evHmZ2vf48eO4uLhgZKS9ZGvUqIGfnx+DBw8GwNbWVpdsgrYEk5WVVRZFLoQQuV+qRs2UM2t4GB/Bb4F/ExVjxIM4c+qvWMGenj3xdHTUd4h5mmL3217Vb6du3bpKhSGE4g4dOsTp06dfSjaBNPM3v0poaCjW1ta6ZRsbG0JDQ9Pd9vTp09ja2tK0adMMj5eYmEh0dHSahxBC5GUGqGhc1AMjlbYWp611Cp7lY4nTxNBo5UqOBgfrOcK8TTp4CZHNpkyZQkhICEFBQQQFBWWYKL6Kg4MDMTExuuXo6GgcHBxe2u769essXLjwtXNSz5o1C1tbW92jRIkSbxyTEELkJiqVival6jC/9qcUNNV+gTcz1VC5fCwmljE0X7OGvbdu6TnKvEsSTiGyWbly5Wjbti0rVqzAx8eH3bt3v/ExvLy8CAwMJCUlBQB/f3+8vb0JCgpCrVYDcPHiRebNm8fixYvRaDTs2LEjw+P5+voSFRWlewTLN3shRD5RuaALy+qPxN2uFACGBlDOJZ4iRaJpu34df1y9qucI8ybFE87/tu74+/tz8+ZNpcMQQnGTJ0/G3d2dHj166NYlJiZmal8rKyvmzZvH0KFDGTNmDL169cLV1ZWOHTty4cIFIiIiaNy4MZcvX6ZFixY0b978pXmlX2RqaoqNjU2ahxBC5BeFzGxZUHsw7Ur+WxO5eJEkyrhG0+2PX1lz/rweo8ubFC/8Pn36dBYsWKBbNjMzY+TIkWzbtk3pUIRQxItFhv9bcHjMmDFprodX8fHxwcfHJ826F5PKJ0+evEOUQgiRv5gYGjGmchfK2Zbg20u/k6JJxc46lUrlYxi0ZzMJKSn0q1ZN32HmGYolnIcOHQLg/v37up9BO5pWiLxs8+bNusTw1q1b1Kz575y/QUFBmU44hRBCZL12pWpT2qYoE0+tJCwxGjMTDR7lYkkyDnv9ziLTFEs4J0+eDEBAQIDuZwBzc3O6dOmiVBhCKM7d3f2lGYae++WXXxSORgghxH+9V8CZpfVH8sXplVyKuIOBAWwI8iPZIJYhFdtjZGCo7xBzPcUSzoMHDwKwdu1aPvzwQ6VOK4TeTZs2jXr16qX7nNSgFUKInKGQmQ0Lan/Kgstb2HL3KACb7/zDzegQplX9CDtTawxkHva3pvigIUk2RX6TUbIJUoNWCCFyEmMDI0ZV6szYyl0wftaqeT78Np33zeKDLWtIlm6Ab03xhPPRo0d8+OGHdOzYkadPn9KnTx/CwqSfhBBCCCFyBp+SXnxfewiFTLUVPJ4mJ7Ht6i06b9xIwrPydOLNKJ5wjh49miZNmmBpaYmlpSVDhw5l7NixSochhBAiF9u5cyefffYZ48aNY/HixS89P3ToUCZOnMjUqVPp2LEjEREReohS5GbuBUqxtP5ISpoX49YdK5KSDdh2/To+69YRm5Sk7/ByHcUTzhIlStCnTx/dPM8eHh4UKFBA6TCEEELkUrGxsYwYMYJvv/2W2bNns2rVKm79Z4YYFxcXvvzySyZPnkzRokVfO/uWEOmxN7Phlyaj+LV9LyyNjQHYHxhI819WcjvysZ6jy10UTzif1wp8Xo8wJiZGCr8LIYTItOPHj+Pi4oKRkXbca40aNfDz80uzzYgRIwDQaDTcvn2b8uXLKx6nyBtUKhVNS5dmb8+e2JmZARqiTG7S86+5HA6RWYkyS/GEs3nz5ri7u7N7925atmyJq6trmplXhBBCiFcJDQ3F2tpat2xjY/PSLHagTUw/+OADSpcuTbNmzTI8XmJiItHR0WkeQvxX7RIl+KtXL8o6gb1dCgZGKYw9uZyb4TLpRmYolnDevXsXgPfff5/ff/+dkSNH0q5dO/755x86deqkVBhCCCFyOQcHB2JiYnTL0dHRODg4vLSdl5cXv/32G0WLFmX8+PEZHm/WrFnY2trqHiVKlMiWuEXu5+HoyC+tPyYh3hSNBq4GmtJk1RoCZPDzaymWcE6cOJGgoCCCgoIwNzenbdu2tG3bFjMzM4KCgpQKQwghRC7n5eVFYGAgKc9GC/v7++Pt7U1QUBBqtRqAlStX6rZ3dXV9qY/ni3x9fYmKitI9goODszV+kbvVKFqKX5uNIfKhI5HRxhgZGGDxrH+nyJhihd+vXbvGypUr0Wg0gLZPRFxcHD/88AMuLi5cvHhRqVCEEELkYlZWVsybN4+hQ4diaWlJr169cHV1pXr16ixduhRPT0/27dunSxzPnTvH9OnTMzyeqakppqamSoUv8oDSBQqyv9un9N66lYWtW1Pcxoa7kZEsvbGTgia2HHlynk4lmlDOxplCFhaUtLXVd8h6p1jCOXLkSLp166ZbvnnzJp06daJFixYyelAIIcQb8fHxwcfHJ826U6dO6X6WaWNFditiZcWfzyazCYqKosGvcylZPA6NBlQq+Orc75y/ZomZkTHXhwzBLp/PUqTYLfUXk80dO3ZQq1YtXX/O5yWShBBCCCFym8dPn2JjnQhok00Aa8tU7GxSSEhJ4UlcnB6jyxkUHaWu0WiYMGECH330EatWrWLixIlKnl4IIYQQIssZqFRcDrAgMUnFs56DaDRQqlgioNFrbDmFYrfUw8PD6datG8HBwRw7doxy5crpnjt9+jTVqlVTKhQhhBBCiCxla5OKqcm/yaVK9W8rp1Aw4axSpQpGRkbMnz+fR48e8ejRI0Db6rlgwQI2b96sVChCCCGEEFlGo9FQqliirv/mv+t5tl5aORVLOF1dXenVqxdhYWGE/adelRTZFUIIIURulapJxdREzX/HBalUYGqiJlWTqp/AchDFEs5x48bRokWLdJ8rXry4UmEIIYQQQmQpRysbrgbYoubl2+cGGOHYxEYPUeUsiiWcGSWbwCunHBNCCCGEyMlK2tpyacCwdEejP6/Dmd/v5iqWcAohhBBC5FUlbW2lwPsr5ImEc+fOnfj5+WFpaYmzszMDBw7Ud0hCZLnX/Z7fvHmTWbNm4erqyuPHj5k7dy5GRnniEhdCCJHL5fpPo9jYWEaMGMGVK1cwMjKidu3aNG/eHFdXV32HJkSWyczv+cCBA/nmm2/w8PDg888/Z82aNXz88cd6jFoIIYTQyvUJ5/Hjx3FxcdG15NSoUQM/Pz8GDx6cZrvExEQSExN1y1FRUUD6I+TVCQmQkEBIYiLFZs7Mxuj/9TA2FjQa1MbGL8Uk8eSueJ4vZ2UZjNf9niclJXH06FE8PDwA8PLyYv369RkmnG9yPSSoE0gggcSQRGYWy/73N/ZhLBo0GKtffm/1Ec/rYpJ4Xh1PdlwP2e15rPm9z53IWrnxWshKuT7hDA0NxdraWrdsY2NDaGjoS9vNmjWLqVOnvrS+RIkSGR5bAzzIkigz7wFgO2FCus9JPLkrnpiYGGyzqD/P637Pw8LCsLCwyPD5/3qb60HxN/gBTLBN/70F9PYfnmFMEs8r48nK6yG7xcTEAK+5HoR4S7npWshKuT7hdHBw0P1xAO03iBdnMXrO19eXkSNH6pbVajXh4eHY29uj+m/hrLcUHR1NiRIlCA4OxsZG/yUQJB79xKPRaIiJiaFYsWJZdszX/Z7b29sT98LoyOjoaBwcHDI8nlwPEo9S8WTH9ZDdihUrRnBwMNbW1i9dDznt/y0zcmPMkPfizo3XQlbK9Qmnl5cXgYGBpKSkYGRkhL+/P8OGDXtpO1NTU0xNTdOss7Ozy5aYbGxsctTFIfG8WnbEk9XfXjP6PQ8KCsLJyQkTExPq1KnD+fPn8fDw4Pjx47Ru3TrD48n1IPFkJDdcD9nNwMAAJyenV26T0/7fMiM3xgx5K+7cdi1kpVyfcFpZWTFv3jyGDh2KpaUlvXr1kgFDIs/J6Pe8evXqLF26FE9PTxYvXsyMGTMoXbo0iYmJ9OzZU99hCyGEEEAeSDgBfHx88PHx0XcYQmSr9H7PT506pfvZzc2NFStWKB2WEEII8VoG+g4gLzE1NWXy5Mkv3arUF4nn1XJaPHlNTnt/JZ5Xy2nx5FS58X3KjTGDxJ3XqDT5dXy+EEIIIYRQhLRwCiGEEEKIbCUJpxBCCCGEyFaScAohhBBCiGwlCedrXLp0ie7duzN37lwGDBjAsv+3d38hTS1wHMC/+VZkKLYKwkbYUxK9hEQ9+DCIiKiHosBFZMtqoc6QwBYVbNkpECxCCunaS5gMBIlCKlrUQ4hgKYJCGklC5d9sR91Y5fc+xB232827NeeO3e/nzZ159kV/3/GDHXb++AMA8PDhQzidTlRXV2PPnj34+PEjAGB4eBhHjhyBYRg4fvw4JicnAQA1NTVYtGgRLly4AACora1FQUEBAoHAnOR58OABjh49CsMwUFpaimg0Oi95wuEwdu/ejUuXLsHj8aCiogIA0N/fD5fLhYsXL6KiogJfvnxJax7TNHH69OkfvltvamoKbrcbhmHA5XJhaGgIAHDz5k1kZWWhtLQUkUgEgUAA+fn5qK+vTyjP70Z9mJ36sPBYbaaTzZ2u2Y+X1TqSTGb1KEGUWQWDQQaDQZJkNBpldnY2x8fHuXHjRr58+ZIkeeLECV65coUk6XK52NLSQpKsq6vjuXPnYucCwHA4zO7ubno8Hk5PT89JntHRUdpsNk5MTJAky8rKeOPGjXnJMzk5yfr6+tjP69evZ2dnJx0OBzs7O0mSp06dYkNDQ1rztLa2sq2tjStXrvzu+X6/P/a/u3//Pg8ePBg7Zrfb2dvby8HBQbrdbo6Ojiac53ejPsxOfVh4rDbTyeRO5+zHy2odSSazepQYLZwJiEajXLFiBUOhELdt28ZHjx6RJJ1OZ6z4q1ev5rt370iSHR0d3LRpU+z3AfDu3bs8f/48v379Omd53r59y+zs7NjjNTU13L9//7zn+fTpE/Py8vjhwwcuXrw49nhzczP37t2btjzDw8MkyTdv3vzwxrB161Y+f/6cJDk2Nsbly5fHjtntdt65c4cnT55kJBJJOs/vRn2Ynfqw8FhtphPNbZXZj5fVOpJIZvUocfpIPQHXr1+H1+tFZmYmLl++DJ/Ph7KyMkxNTWHDhg0AgJGREWRmZgL4dlurkZGR785RUlICh8OBjIzk//R/5cnNzYXNZkNfXx8AoKOjA6FQaF7zNDY2YteuXfB6vZiZmcGSJUtix/7+uunIM9s9xf+ZZ2xsDDMzM7Hjbrcbmzdv1vep/Qv14efUh4XJajOdaG4rzH68rNaRRDOrR4nTwhmn5uZmmKYJj8eDaDSKnTt3IhAI4Nq1a3A4HLH7t9tsNpimCQAIhUI/DGUgEEBRURGePXs2Z3kA4N69e2hoaMDVq1dht9uxZs2aec1TVFSEYDCIpqYmtLe3Y3p6Onbs76+bjjytra0/fd4/8+Tk5Hz3xnX79m1UVVWl7HqmhUp9mJ36sPBYbaZ/JTeQ/tmPl9U6kmhm9ShxWjjj0NjYiIGBAZw5cwZdXV3o7e3FxMQEcnJyAACrVq1COBwGAGzfvh3t7e0AgLa2NuzYseO7cxUUFKClpQVOpxNPnz6dkzyvXr2CaZowDCP2puN0OuclT09PT+z8GRkZWLt2LQYHB7FlyxZ0dXX98LrpyPP69eufPv+/8uTl5eHx48fwer1oampKOM/vSH34OfVhYbLaTP9q7nTOfrys1pFfzawe/YJ0f6ZvdcFgkMuWLWNhYSELCwuZn5/PJ0+esK6ujsXFxayurua+ffvY09NDkhwaGuLhw4fp8/lYUlJC0zRJkrW1tQRAwzBIki9evGBubi7Pnj3LaDSadB6Xy8Xy8nIahhG7SHw+8vT399PpdNIwDFZVVfHAgQM0TZN9fX08dOgQfT4fy8vL+fnz57Tm6e7uZmVlJZcuXUq/38/x8XGS3y4GP3bsGP1+P4uLi/n+/XuS5K1bt5iVlUWPx8NIJMKBgQGuW7eOlZWVsWt3/o/Uh9mpDwuP1WY62dzpmv14Wa0jyWRWjxKjW1uKiIiISErpI3URERERSSktnCIiIiKSUlo4RURERCSltHCKiIiISEpp4RQRERGRlNLCKSIiIiIppYVTRERERFJKC6eIiIiIpJQWThERERFJKS2cIiIiIpJSWjhFREREJKX+BM/uXyDggXhtAAAAAElFTkSuQmCC",
      "text/plain": [
       "<Figure size 700x600 with 7 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "def make_composite_figure(save_path=None):\n",
    "    \"\"\"\n",
    "    Create a 2x3 composite figure by combining three specialized plotting functions.\n",
    "    \n",
    "    Layout:\n",
    "    [0,0]: M_net vertical profile (single panel)\n",
    "    [0,1],[0,2]: Masked precipitation maps (two panels with shared colorbar)  \n",
    "    [1,0]-[1,2]: Metrics panels (three panels: mass flux, area fraction, normalized comparison)\n",
    "    \n",
    "    Parameters\n",
    "    ----------\n",
    "    save_path : str, optional\n",
    "        Path to save the figure. If None, figure is displayed but not saved.\n",
    "    \n",
    "    Returns\n",
    "    -------\n",
    "    matplotlib.figure.Figure\n",
    "        The composed figure object.\n",
    "    \"\"\"\n",
    "    # Create overall figure - total size for LaTeX two-column format\n",
    "    # Width: ~7 inches for two-column, Height: sum of row heights + spacing\n",
    "    fig = plt.figure(figsize=(7.0, 6.0))\n",
    "    \n",
    "    # Create main 2x3 GridSpec \n",
    "    # height_ratios: top row vs bottom row height allocation\n",
    "    # wspace: horizontal space between columns, hspace: vertical space between rows\n",
    "    gs = GridSpec(2, 3, figure=fig, height_ratios=[1, 1], \n",
    "                  wspace=0.3, hspace=0.2)\n",
    "    \n",
    "    # --- TOP ROW ---\n",
    "    \n",
    "    # Panel [0,0]: M_net vertical profile\n",
    "    # Single panel taking first column of top row\n",
    "    ax1 = make_mnet_profile_panel(\n",
    "        fig=fig,\n",
    "        position=gs[0, 0],\n",
    "        ds_dict=mf_net,           # Your stored data\n",
    "        xvar='mf',              # Variable to plot\n",
    "        temp_cases=['280K', '290K', '300K', '310K'],  # Temperature cases\n",
    "        ycoord='pfull',            # Vertical coordinate (pressure)\n",
    "        lcl_dict=LCL_dict          # LCL data for masking\n",
    "    )\n",
    "    \n",
    "    # Panels [0,1] and [0,2]: Masked precipitation maps  \n",
    "    # Two panels with shared colorbar, taking columns 1 and 2 of top row\n",
    "    precip_result = make_masked_precip_panels(\n",
    "        fig=fig,\n",
    "        positions=[gs[0, 1], gs[0, 2]],  # Positions for both panels\n",
    "        precip_data_dict=lpf_masked_prec,  # Your stored precipitation data\n",
    "        temp_cases=['280K', '310K'],       # Two temperature cases to compare\n",
    "        time_steps=[46, -1] # Time steps for each case\n",
    "    )\n",
    "    ax2, ax3 = precip_result['axes']  # Unpack the two axes\n",
    "    \n",
    "    # --- BOTTOM ROW ---\n",
    "    \n",
    "    # Panels [1,0] to [1,2]: Metrics overview\n",
    "    # Three panels spanning entire bottom row\n",
    "    ax4, ax5, ax6 = make_metrics_panels(\n",
    "        fig=fig,\n",
    "        positions=[gs[1, 0], gs[1, 1], gs[1, 2]],  # All three bottom positions\n",
    "        df=df,              # Your stored metrics dataframe\n",
    "        ds_mf=ds_mf,       # Your stored mass flux data  \n",
    "        delta_dic=delta_dic # Your stored delta value\n",
    "    )\n",
    "    \n",
    "    # --- ADD PANEL LABELS ---\n",
    "    \n",
    "    # Labels for each panel: a, b, c, d, e, f\n",
    "    labels = ['a', 'b', 'c', 'd', 'e', 'f']\n",
    "    axes = [ax1, ax2, ax3, ax4, ax5, ax6]\n",
    "    \n",
    "    for i, ax in enumerate(axes):\n",
    "        # Place label in top-left corner outside panel\n",
    "        ax.text(-0.1, 1.01, labels[i], transform=ax.transAxes,\n",
    "                fontsize=12, ha='right', va='bottom', color='black',\n",
    "                weight='bold')\n",
    "    \n",
    "    # --- FINAL LAYOUT AND SAVE ---\n",
    "    \n",
    "    # Apply tight layout to minimize whitespace\n",
    "    #plt.tight_layout()\n",
    "    \n",
    "    # Save if requested\n",
    "    if save_path:\n",
    "        plt.savefig(save_path, dpi=600, bbox_inches='tight')\n",
    "        print(f\"Composite figure saved to: {save_path}\")\n",
    "    \n",
    "    return fig\n",
    "\n",
    "# Example usage:\n",
    "fig = make_composite_figure(save_path=sdir)\n",
    "plt.show()"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.10.7"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}
